diff --git a/.classpath b/.classpath index a9b51ac..8d2daaf 100644 --- a/.classpath +++ b/.classpath @@ -6,12 +6,6 @@ - - - - - - diff --git a/gradle.properties b/gradle.properties index f461305..d904fce 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ org.gradle.jvmargs=-Xmx3G -maxMemory = 1024m -testThreads = 2 \ No newline at end of file +maxMemory = 2048m +testThreads = 4 \ No newline at end of file diff --git a/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java b/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java index 41bbc82..ac4ab3f 100644 --- a/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java +++ b/src/builder/java/speiger/src/builder/PrimitiveCollectionsBuilder.java @@ -128,6 +128,7 @@ public class PrimitiveCollectionsBuilder extends TemplateProcessor for(int i = 0,m=modules.size();i parsedData = new TreeMap<>(); JsonObject data = new JsonObject(); Set moduleNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); + Set allDependencies = new LinkedHashSet<>(); - public boolean isModuleEnabled(BaseModule base, ClassType keyType, ClassType valueType) { - if(!loaded) return true; - if(!isEnabled(data, base.getModuleName())) return false; - JsonObject result = getObject(data, keyType.getClassPath(), false); - if(!isEnabled(result, "Enabled")) return false; - if(base.isBiModule()) { - result = getObject(result, valueType.getClassPath(), false); - if(!isEnabled(result, "Enabled")) return false; + public void resolve() { + if(!loaded) return; + Set roots = new LinkedHashSet<>(); + Set leafs = new LinkedHashSet<>(); + for(IDependency entry : allDependencies) { + if(entry.isRoot()) { + roots.add(entry); + } + if(entry.isLeaf()) { + leafs.add(entry); + } } - result = getObject(result, base.getModuleName(), false); - return (result.size() <= 0 || isEnabled(result, "Enabled")) && base.areDependenciesLoaded(); - } - - public boolean isModuleEnabled(BaseModule base, ClassType keyType, ClassType valueType, String entry) - { - if(!loaded) return true; - if(!isEnabled(data, base.getModuleName())) return false; - JsonObject result = getObject(data, keyType.getClassPath(), false); - if(!isEnabled(result, "Enabled")) return false; - if(base.isBiModule()) { - result = getObject(result, valueType.getClassPath(), false); - if(!isEnabled(result, "Enabled")) return false; + /** + * This has to be 2 iteration passes. + * Due to Key Value Pairs, first pass does all initials keys, and the second pass processes the values. + * May require more passes but extremely unlikely + */ + for(int i = 0;i<2;i++) { + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + for(IDependency entry : roots) { + entry.resolveRequirements(keyType, valueType); + } + } + } + } + + List errors = new ArrayList<>(); + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + for(IDependency entry : leafs) { + entry.validateDependency(errors::add, keyType, valueType); + } + } + } + if(errors.size() > 0) { + throw new IllegalStateException("Issues with dependencies found: "+String.join("\n", errors)); } - result = getObject(result, base.getModuleName(), false); - return (result.size() <= 0 || (isEnabled(result, "Enabled") && isEnabled(result, entry))) && base.areDependenciesLoaded(); } public void addModule(BaseModule module) { - if(loaded) return; + if(loaded) { + if(module.isBiModule()) { + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + if(!module.isModuleValid(keyType, valueType)) continue; + for(IDependency dependency : module.getDependencies(keyType, valueType)) { + dependency.set(parsedData); + allDependencies.add(dependency); + } + } + } + return; + } + for(ClassType keyType : ModulePackage.TYPE) { + if(!module.isModuleValid(keyType, keyType)) continue; + for(IDependency dependency : module.getDependencies(keyType, keyType)) { + dependency.set(parsedData); + allDependencies.add(dependency); + } + } + return; + } String moduleName = module.getModuleName(); moduleNames.add(moduleName); data.addProperty(moduleName, true); @@ -57,9 +103,9 @@ public class SettingsManager for(ClassType valueType : ModulePackage.TYPE) { if(!module.isModuleValid(keyType, valueType)) continue; JsonObject obj = new JsonObject(); - obj.addProperty("Enabled", true); - for(String key : module.getModuleKeys(keyType, valueType)) { - obj.addProperty(key, true); + for(IDependency dependency : module.getDependencies(keyType, valueType)) { + String key = dependency.getName(); + if(key != null) obj.addProperty(key, true); } addModule(keyType, valueType, true, moduleName, obj); } @@ -69,18 +115,61 @@ public class SettingsManager for(ClassType keyType : ModulePackage.TYPE) { if(!module.isModuleValid(keyType, keyType)) continue; JsonObject obj = new JsonObject(); - obj.addProperty("Enabled", true); - for(String key : module.getModuleKeys(keyType, keyType)) { - obj.addProperty(key, true); + for(IDependency dependency : module.getDependencies(keyType, keyType)) { + String key = dependency.getName(); + if(key != null) obj.addProperty(key, true); } addModule(keyType, keyType, false, moduleName, obj); } } + public void printModuleSettings(List modules) { + JsonObject data = new JsonObject(); + for(BaseModule module : modules) { + String moduleName = module.getModuleName(); + if(module.isBiModule()) { + for(ClassType keyType : ModulePackage.TYPE) { + for(ClassType valueType : ModulePackage.TYPE) { + if(!module.isModuleValid(keyType, valueType)) continue; + JsonObject obj = new JsonObject(); + for(IDependency dependency : module.getDependencies(keyType, valueType)) { + String key = dependency.getName(); + if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, valueType).getJsonResult()); + } + addModule(data, keyType, valueType, true, moduleName, obj); + } + } + continue; + } + for(ClassType keyType : ModulePackage.TYPE) { + if(!module.isModuleValid(keyType, keyType)) continue; + JsonObject obj = new JsonObject(); + for(IDependency dependency : module.getDependencies(keyType, keyType)) { + String key = dependency.getName(); + if(key != null) obj.addProperty(key, dependency.isLoaded(keyType, keyType).getJsonResult()); + } + addModule(data, keyType, keyType, false, moduleName, obj); + } + } + try { + System.out.println(); + JsonWriter writer = new JsonWriter(new OutputStreamWriter(System.out)); + writer.setIndent("\t"); + Streams.write(data, writer); + writer.flush(); + System.out.println(); + } catch (IOException e) { + e.printStackTrace(); + } + } + public void load() { try(BufferedReader reader = Files.newBufferedReader(Paths.get("ModulSettings.json"))) { data = JsonParser.parseReader(reader).getAsJsonObject(); loaded = true; + IDependency.flatten("", false, data, parsedData); + JsonElement element = data.get("Default"); + LoadingState.setOptionalResolver(LoadingState.of(element == null ? true : element.getAsBoolean())); } catch(Exception e) { e.printStackTrace(); } } @@ -100,6 +189,14 @@ public class SettingsManager catch(Exception e) { e.printStackTrace(); } } + private void addModule(JsonObject data, ClassType keyType, ClassType valueType, boolean bi, String moduleName, JsonObject obj) { + JsonObject result = getObject(data, keyType.getClassPath(), true); + if(bi) { + result = getObject(result, valueType.getClassPath(), true); + } + result.add(moduleName, obj); + } + private void addModule(ClassType keyType, ClassType valueType, boolean bi, String moduleName, JsonObject obj) { JsonObject result = getObject(data, keyType.getClassPath(), true); if(bi) { @@ -117,9 +214,4 @@ public class SettingsManager } return obj; } - - private boolean isEnabled(JsonObject obj, String key) { - if(obj.has(key)) return obj.getAsJsonPrimitive(key).getAsBoolean(); - return true; - } } diff --git a/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java b/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java new file mode 100644 index 0000000..fa9381a --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/BaseDependency.java @@ -0,0 +1,137 @@ +package speiger.src.builder.dependencies; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.StringJoiner; +import java.util.TreeSet; +import java.util.function.Consumer; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.Requirements.Requirement; + +@SuppressWarnings("javadoc") +public abstract class BaseDependency implements IDependency { + protected static boolean FETCH_FAILURES = false; + protected static Set FAILURE_KEYS = new TreeSet<>(); + + protected final String name; + protected final boolean biType; + protected Map dependencies; + protected List children = new ArrayList<>(); + protected List requirements = new ArrayList<>(); + protected ClassType keyType; + protected ClassType valueType; + + public BaseDependency(String name, boolean biType) { + this.name = name; + this.biType = biType; + } + + @Override + public String toString() { + return name; + } + + @Override + public void set(Map dependency) { + dependencies = dependency; + } + + @Override + public IDependency addDependency(Requirement require) { + requirements.add(require); + require.dependency.addChild(this); + return this; + } + + @Override + public void addChild(IDependency child) { + children.add(child); + } + + @Override + public boolean isLeaf() { + return children.isEmpty(); + } + + @Override + public boolean isRoot() { + return requirements.isEmpty(); + } + + protected LoadingState getGlobalState() { + return dependencies.getOrDefault(name, LoadingState.OPTIONAL); + } + + @Override + public String getLocalStateKey(ClassType keyType, ClassType valueType) { + return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+name; + } + + protected LoadingState getLocalState(ClassType keyType, ClassType valueType) { + return dependencies.getOrDefault(getLocalStateKey(keyType, valueType), LoadingState.OPTIONAL); + } + + protected LoadingState getReqirementState(ClassType keyType, ClassType valueType) { + LoadingState state = requirements.isEmpty() ? LoadingState.REQUIRED : LoadingState.OPTIONAL; + for(int i = 0,m=requirements.size();i result, ClassType keyType, ClassType valueType) { + if(getLocalState(keyType, valueType) == LoadingState.REQUIRED) { + FETCH_FAILURES = true; + for(Requirement req : requirements) { + req.test(keyType, valueType); + } + FETCH_FAILURES = false; + if(FAILURE_KEYS.size() > 0) { + int size = FAILURE_KEYS.size(); + StringJoiner joiner = new StringJoiner("], [", "[", "]"); + FAILURE_KEYS.forEach(joiner::add); + FAILURE_KEYS.clear(); + String joins = size > 1 ? "["+joiner.toString()+"]" : joiner.toString(); + + result.accept("["+getLocalStateKey(keyType, valueType)+"] Requires "+joins+" but it specifically has been disabled!"); + } + + } + } + + @Override + public void set(ClassType key, ClassType value) { + this.keyType = key; + this.valueType = value; + } + + @Override + public boolean isEnabled() { + if(keyType == null || keyType == null) return false; + return isLoaded(keyType, valueType).getJsonResult(); + } + + @Override + public String getName() { + return name; + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java b/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java new file mode 100644 index 0000000..b53fdff --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/FunctionDependency.java @@ -0,0 +1,29 @@ +package speiger.src.builder.dependencies; + +import speiger.src.builder.ClassType; + +@SuppressWarnings("javadoc") +public class FunctionDependency extends BaseDependency { + ModuleDependency owner; + + public FunctionDependency(ModuleDependency owner, String name) { + super(name, owner.biType); + this.owner = owner; + } + + @Override + public LoadingState isLoaded(ClassType key, ClassType value) { + if(dependencies == null) return LoadingState.REQUIRED; + LoadingState result = getLocalState(key, value); + if(FETCH_FAILURES && result == LoadingState.REJECTED) { + FAILURE_KEYS.add(getLocalStateKey(key, value)); + } + return result.resolveIfUndefined().merge(getReqirementState(key, value)); + } + + @Override + public String getLocalStateKey(ClassType keyType, ClassType valueType) { + return (biType ? keyType.getClassPath()+"-"+valueType.getClassPath() : keyType.getClassPath())+"-"+owner.getName()+"-"+name; + } + +} diff --git a/src/builder/java/speiger/src/builder/dependencies/IDependency.java b/src/builder/java/speiger/src/builder/dependencies/IDependency.java new file mode 100644 index 0000000..e28dc9b --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/IDependency.java @@ -0,0 +1,104 @@ +package speiger.src.builder.dependencies; + +import java.util.Map; +import java.util.Map.Entry; +import java.util.function.Consumer; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.Requirements.Requirement; + +@SuppressWarnings("javadoc") +public interface IDependency { + + + public void set(Map dependency); + public void set(ClassType key, ClassType value); + public LoadingState isLoaded(ClassType key, ClassType value); + public String getLocalStateKey(ClassType keyType, ClassType valueType); + public boolean isEnabled(); + public boolean isLeaf(); + public boolean isRoot(); + + public String getName(); + public void validateDependency(Consumer result, ClassType keyType, ClassType valueType); + public void resolveRequirements(ClassType keyType, ClassType valueType); + + public void addChild(IDependency child); + public T addDependency(Requirement require); + public default T addKeyDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.KEY_TEST, Requirements.KEY_GETTER)); } + public default T addValueDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.VALUE_TEST, Requirements.VALUE_GETTER)); } + public default T addEntryDependency(IDependency dependency) { return addDependency(new Requirement(dependency, Requirements.ENTRY_TEST, Requirements.ENTRY_GETTER)); } + public default T addTypeDependency(IDependency dependency, ClassType type) { return addDependency(new Requirement(dependency, Requirements.typedTest(type), Requirements.typedKey(type))); } + public default T addOptionalTypeDependency(IDependency dependency, ClassType type, boolean key) { return addDependency(new Requirement(dependency, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); } + public default T addOptionalTypeDependency(ClassType type, boolean key) { return addDependency(new Requirement(this, Requirements.optionalTest(type, key), Requirements.optionalKey(type, key))); } + + + public static void flatten(String prefix, boolean applyMiddle, JsonObject object, Map result) { + if(applyMiddle) prefix+="-"; + for(Entry entry : object.entrySet()) { + String key = entry.getKey(); + JsonElement value = entry.getValue(); + if(value instanceof JsonPrimitive) { + String entryKey = prefix+key; + if("Enabled".equalsIgnoreCase(key)) { + entryKey = prefix.substring(0, prefix.length()-1); + } + result.put(entryKey, LoadingState.of(((JsonPrimitive)value).getAsBoolean())); + } + if(value instanceof JsonObject) { + flatten(prefix+key, true, (JsonObject)value, result); + } + } + } + + public static enum LoadingState { + OPTIONAL, + REQUIRED, + REJECTED; + + private static LoadingState RESOLVED = LoadingState.REQUIRED; + + public static LoadingState of(boolean value) { + return value ? REQUIRED : REJECTED; + } + + public LoadingState merge(LoadingState merge) { + return ordinal() > merge.ordinal() ? this : merge; + } + + public LoadingState replaceIfUndefined(LoadingState state) { + return this == OPTIONAL ? state : this; + } + + public LoadingState resolveIfUndefined() { + return this == OPTIONAL ? RESOLVED : this; + } + + public LoadingState mergeDown(LoadingState merge) { + if(merge == REJECTED || ordinal() > merge.ordinal()) { + return this; + } + return merge; + } + + public LoadingState mergeUp(LoadingState merge) { + if(merge == REQUIRED || ordinal() > merge.ordinal()) { + return this; + } + return merge; + } + + public static void setOptionalResolver(LoadingState state) { + RESOLVED = state; + } + + public boolean getJsonResult() { + LoadingState state = this == OPTIONAL ? RESOLVED : this; + return state == REQUIRED; + } + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java b/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java new file mode 100644 index 0000000..20d39da --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/ModuleDependency.java @@ -0,0 +1,31 @@ +package speiger.src.builder.dependencies; + +import speiger.src.builder.ClassType; +import speiger.src.builder.modules.BaseModule; + +@SuppressWarnings("javadoc") +public class ModuleDependency extends BaseDependency { + BaseModule owner; + + public ModuleDependency(BaseModule owner, boolean biType) { + super(owner.getModuleName(), biType); + this.owner = owner; + } + + public FunctionDependency createDependency(String name) { + FunctionDependency result = new FunctionDependency(this, name); + if(biType) result.addEntryDependency(this); + else result.addKeyDependency(this); + return result; + } + + @Override + public LoadingState isLoaded(ClassType key, ClassType value) { + if(dependencies == null) return LoadingState.REQUIRED; + LoadingState result = getLocalState(key, value); + if(FETCH_FAILURES && result == LoadingState.REJECTED) { + FAILURE_KEYS.add(getLocalStateKey(key, value)); + } + return result.replaceIfUndefined(getGlobalState()).resolveIfUndefined().merge(getReqirementState(key, value)); + } +} diff --git a/src/builder/java/speiger/src/builder/dependencies/Requirements.java b/src/builder/java/speiger/src/builder/dependencies/Requirements.java new file mode 100644 index 0000000..9940340 --- /dev/null +++ b/src/builder/java/speiger/src/builder/dependencies/Requirements.java @@ -0,0 +1,68 @@ +package speiger.src.builder.dependencies; + +import java.util.function.Consumer; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.IDependency.LoadingState; + +@SuppressWarnings("javadoc") +public class Requirements { + public static final RequirementTest KEY_TEST = (T, K, V) -> T.isLoaded(K, K); + public static final RequirementTest VALUE_TEST = (T, K, V) -> T.isLoaded(V, V); + public static final RequirementTest ENTRY_TEST = (T, K, V) -> T.isLoaded(K, V); + + public static RequirementTest typedTest(ClassType type) { + return (T, K, V) -> T.isLoaded(type, type); + } + + public static RequirementTest optionalTest(ClassType type, boolean key) { + return (T, K, V) -> (key ? K : V) != type ? T.isLoaded(type, type) : LoadingState.REQUIRED; + } + + public static final RequirementKey KEY_GETTER = (T, K, V) -> T.getLocalStateKey(K, K); + public static final RequirementKey VALUE_GETTER = (T, K, V) -> T.getLocalStateKey(V, V); + public static final RequirementKey ENTRY_GETTER = (T, K, V) -> T.getLocalStateKey(K, V); + + public static RequirementKey typedKey(ClassType type) { + return (T, K, V) -> T.getLocalStateKey(type, type); + } + + public static RequirementKey optionalKey(ClassType type, boolean key) { + return (T, K, V) -> (key ? K : V) != type ? T.getLocalStateKey(type, type) : ""; + } + + + + public interface RequirementTest { + public LoadingState test(IDependency test, ClassType keyType, ClassType valueType); + } + + public static interface RequirementKey { + public String key(IDependency test, ClassType keyType, ClassType valueType); + } + + public static interface RequirementResolver { + public void resolve(IDependency test, Consumer result, ClassType keyType, ClassType valueType); + } + + public static class Requirement { + IDependency dependency; + RequirementTest test; + RequirementKey key; + + public Requirement(IDependency dependency, RequirementTest test, RequirementKey key) { + this.dependency = dependency; + this.test = test; + this.key = key; + } + + public LoadingState test(ClassType keyType, ClassType valueType) { + return test.test(dependency, keyType, valueType); + } + + public String key(ClassType keyType, ClassType valueType) { + return key.key(dependency, keyType, valueType); + } + + } +} diff --git a/src/builder/java/speiger/src/builder/modules/AsyncModule.java b/src/builder/java/speiger/src/builder/modules/AsyncModule.java index 75a0eb5..832b314 100644 --- a/src/builder/java/speiger/src/builder/modules/AsyncModule.java +++ b/src/builder/java/speiger/src/builder/modules/AsyncModule.java @@ -1,9 +1,17 @@ package speiger.src.builder.modules; +import java.util.Arrays; +import java.util.List; + +import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; + @SuppressWarnings("javadoc") public class AsyncModule extends BaseModule { public static final BaseModule INSTANCE = new AsyncModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE); @Override public String getModuleName() { return "Async"; } @@ -16,16 +24,16 @@ public class AsyncModule extends BaseModule @Override protected void loadFunctions() {} @Override - public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); } + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) { + if(!MODULE.isEnabled()) { addBlockedFiles("AsyncBuilder", "Task"); } } @Override protected void loadFlags() { - if(isModuleEnabled()) { + if(MODULE.isEnabled()) { addKeyFlag("ASYNC_MODULE"); } } diff --git a/src/builder/java/speiger/src/builder/modules/BaseModule.java b/src/builder/java/speiger/src/builder/modules/BaseModule.java index 866b729..33ea237 100644 --- a/src/builder/java/speiger/src/builder/modules/BaseModule.java +++ b/src/builder/java/speiger/src/builder/modules/BaseModule.java @@ -1,13 +1,15 @@ package speiger.src.builder.modules; import java.util.Collections; -import java.util.Set; +import java.util.List; +import java.util.function.Consumer; import java.util.function.Predicate; import speiger.src.builder.ClassType; import speiger.src.builder.ModulePackage; import speiger.src.builder.RequiredType; import speiger.src.builder.SettingsManager; +import speiger.src.builder.dependencies.IDependency; import speiger.src.builder.mappers.ArgumentMapper; import speiger.src.builder.mappers.InjectMapper; import speiger.src.builder.mappers.LineMapper; @@ -30,6 +32,9 @@ public abstract class BaseModule this.entry = entry; keyType = entry.getKeyType(); valueType = entry.getValueType(); + for(IDependency dependency : getDependencies(keyType, valueType)) { + dependency.set(keyType, valueType); + } loadVariables(); loadClasses(); loadTestClasses(); @@ -56,32 +61,12 @@ public abstract class BaseModule public abstract String getModuleName(); public boolean isBiModule() { return false; } - public Set getModuleKeys(ClassType keyType, ClassType valueType) { return Collections.emptySet(); } + public List getDependencies(ClassType keyType, ClassType valueType) { return Collections.emptyList(); } public boolean isModuleValid(ClassType keyType, ClassType valueType) { return true; } public ClassType keyType() { return keyType; } public ClassType valueType() { return valueType; } - protected boolean isModuleEnabled() { - return manager == null || manager.isModuleEnabled(this, keyType, valueType); - } - - protected boolean isModuleEnabled(String name) { - return manager == null || manager.isModuleEnabled(this, keyType, valueType, name); - } - - protected boolean isDependencyLoaded(BaseModule module) { - return isDependencyLoaded(module, true); - } - - protected boolean isDependencyLoaded(BaseModule module, boolean key) { - return manager == null || (module.isBiModule() ? manager.isModuleEnabled(module, keyType, valueType) : (key ? manager.isModuleEnabled(module, keyType, keyType) : manager.isModuleEnabled(module, valueType, valueType))); - } - - public boolean areDependenciesLoaded() { - return true; - } - protected void addFlag(String name) { entry.addFlag(name); } @@ -205,4 +190,9 @@ public abstract class BaseModule entry.addMapper(mapper); return mapper; } + + public static T make(T input, Consumer processor) { + processor.accept(input); + return input; + } } diff --git a/src/builder/java/speiger/src/builder/modules/CollectionModule.java b/src/builder/java/speiger/src/builder/modules/CollectionModule.java index 4987a42..f331a4a 100644 --- a/src/builder/java/speiger/src/builder/modules/CollectionModule.java +++ b/src/builder/java/speiger/src/builder/modules/CollectionModule.java @@ -1,52 +1,59 @@ package speiger.src.builder.modules; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class CollectionModule extends BaseModule { public static final BaseModule INSTANCE = new CollectionModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false) + .addKeyDependency(FunctionModule.MODULE) + .addOptionalTypeDependency(FunctionModule.MODULE, ClassType.OBJECT, true) + .addOptionalTypeDependency(FunctionModule.MODULE, ClassType.INT, true) + .addOptionalTypeDependency(ClassType.OBJECT, true); + public static final FunctionDependency STREAMS = MODULE.createDependency("Streams"); + public static final FunctionDependency SPLIT_ITERATORS = MODULE.createDependency("Splititerators").addKeyDependency(STREAMS); + public static final FunctionDependency IARRAY = MODULE.createDependency("IArray"); + public static final FunctionDependency STRATEGY = MODULE.createDependency("Strategy"); @Override public String getModuleName() { return "Collection"; } @Override protected void loadVariables() {} @Override - public boolean areDependenciesLoaded(){ return isDependencyLoaded(JavaModule.INSTANCE); } - - @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) - { - return new TreeSet<>(Arrays.asList("Streams", "Splititerators", "IArray", "Strategy")); - } + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, STREAMS, SPLIT_ITERATORS, IARRAY, STRATEGY); } @Override protected void loadFlags() { - if(isModuleEnabled()) addKeyFlag("COLLECTION_MODULE"); - if(isModuleEnabled("Streams")) addKeyFlag("STREAM_FEATURE"); - if(isModuleEnabled("Splititerators")) addKeyFlag("SPLIT_ITERATOR_FEATURE"); - if(isModuleEnabled("IArray")) addKeyFlag("IARRAY_FEATURE"); + if(MODULE.isEnabled()) addKeyFlag("COLLECTION_MODULE"); + if(STREAMS.isEnabled()) addKeyFlag("STREAM_FEATURE"); + if(SPLIT_ITERATORS.isEnabled()) addKeyFlag("SPLIT_ITERATOR_FEATURE"); + if(IARRAY.isEnabled()) addKeyFlag("IARRAY_FEATURE"); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) { + if(!MODULE.isEnabled()) { addBlockedFiles("Iterable", "Iterables", "Iterator", "Iterators", "BidirectionalIterator", "ListIterator"); - addBlockedFiles("Arrays", "Collection", "AbstractCollection", "Collections", "Stack"); + addBlockedFiles("Arrays", "Collection", "OrderedCollection", "AbstractCollection", "Collections", "Stack"); } - if(!isModuleEnabled("Splititerators")) addBlockedFiles("Splititerator", "Splititerators"); - if(!isModuleEnabled("IArray")) addBlockedFiles("IArray"); - if(!isModuleEnabled("Strategy")) addBlockedFiles("Strategy"); + if(!SPLIT_ITERATORS.isEnabled()) addBlockedFiles("Splititerator", "Splititerators"); + if(!IARRAY.isEnabled()) addBlockedFiles("IArray"); + if(!STRATEGY.isEnabled()) addBlockedFiles("Strategy"); - if(keyType.isObject()) { + if(keyType.isObject()) + { addBlockedFiles("Stack"); addBlockedFiles("CollectionStreamTester"); } - if(keyType == ClassType.BOOLEAN) { + if(keyType == ClassType.BOOLEAN) + { addBlockedFiles("CollectionRemoveIfTester", "CollectionStreamTester"); addBlockedFilter(T -> T.endsWith("Tester") && T.startsWith("Iterable")); } @@ -84,6 +91,7 @@ public class CollectionModule extends BaseModule { //Abstract Classes addAbstractMapper("ABSTRACT_COLLECTION", "Abstract%sCollection"); + addAbstractMapper("REVERSED_ORDERED_COLLECTION", "Reverse%sOrderedCollection"); //Helper Classes addClassMapper("ARRAYS", "Arrays"); @@ -94,6 +102,7 @@ public class CollectionModule extends BaseModule //Interfaces addClassMapper("COLLECTION", "Collection"); + addClassMapper("ORDERED_COLLECTION", "OrderedCollection"); addClassMapper("ITERABLE", "Iterable"); addClassMapper("SPLIT_ITERATOR", "Splititerator"); addClassMapper("LIST_ITERATOR", "ListIterator"); diff --git a/src/builder/java/speiger/src/builder/modules/FunctionModule.java b/src/builder/java/speiger/src/builder/modules/FunctionModule.java index 999f457..42ce610 100644 --- a/src/builder/java/speiger/src/builder/modules/FunctionModule.java +++ b/src/builder/java/speiger/src/builder/modules/FunctionModule.java @@ -1,12 +1,18 @@ package speiger.src.builder.modules; +import java.util.Arrays; +import java.util.List; + import speiger.src.builder.ClassType; import speiger.src.builder.RequiredType; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class FunctionModule extends BaseModule { public static final BaseModule INSTANCE = new FunctionModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(JavaModule.MODULE); @Override public String getModuleName() { return "Function"; } @@ -19,10 +25,16 @@ public class FunctionModule extends BaseModule @Override protected void loadTestClasses() {} + @Override + public List getDependencies(ClassType keyType, ClassType valueType) { + return Arrays.asList(MODULE); + } + @Override protected void loadBlockades() { if(keyType.isObject()) addBlockedFiles("Consumer", "Comparator"); + if(!MODULE.isEnabled()) addBlockedFiles("Consumer", "BiConsumer", "Comparator", "Supplier", "Function", "UnaryOperator"); } @Override diff --git a/src/builder/java/speiger/src/builder/modules/JavaModule.java b/src/builder/java/speiger/src/builder/modules/JavaModule.java index e172507..da22499 100644 --- a/src/builder/java/speiger/src/builder/modules/JavaModule.java +++ b/src/builder/java/speiger/src/builder/modules/JavaModule.java @@ -1,11 +1,17 @@ package speiger.src.builder.modules; +import java.util.Arrays; +import java.util.List; + import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class JavaModule extends BaseModule { public static final BaseModule INSTANCE = new JavaModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false); @Override public String getModuleName() { return "Base"; } @@ -17,6 +23,11 @@ public class JavaModule extends BaseModule loadBaseVariables(); } + @Override + public List getDependencies(ClassType keyType, ClassType valueType) { + return Arrays.asList(MODULE); + } + @Override protected void loadFlags() { @@ -185,6 +196,7 @@ public class JavaModule extends BaseModule 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("@ValueType", "@param <%s> the keyType of elements maintained by this Collection"); + addSimpleMapper("@Java21", getVersion() >= 21 ? "@Override" : ""); addAnnontion("@PrimitiveOverride", "@Override"); addSimpleMapper("@PrimitiveDoc", ""); addAnnontion("@Primitive", "@Deprecated"); diff --git a/src/builder/java/speiger/src/builder/modules/ListModule.java b/src/builder/java/speiger/src/builder/modules/ListModule.java index e8881f0..e52b688 100644 --- a/src/builder/java/speiger/src/builder/modules/ListModule.java +++ b/src/builder/java/speiger/src/builder/modules/ListModule.java @@ -1,55 +1,57 @@ package speiger.src.builder.modules; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class ListModule extends BaseModule { public static final BaseModule INSTANCE = new ListModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency ARRAY_LIST = MODULE.createDependency("ArrayList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_LIST = MODULE.createDependency("LinkedList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_LIST = MODULE.createDependency("ImmutableList").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency COPY_ON_WRITE_LIST = MODULE.createDependency("CopyOnWriteList").addKeyDependency(IMPLEMENTATION); @Override public String getModuleName() { return "List"; } @Override + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, IMPLEMENTATION, WRAPPERS, ARRAY_LIST, LINKED_LIST, IMMUTABLE_LIST, COPY_ON_WRITE_LIST); } + @Override protected void loadVariables() {} @Override protected void loadFlags() { - if(isModuleEnabled()) addKeyFlag("LIST_MODULE"); - if(isModuleEnabled("Wrappers")) addKeyFlag("LISTS_FEATURE"); - boolean implementations = isModuleEnabled("Implementations"); - if(implementations && isModuleEnabled("ArrayList")) addKeyFlag("ARRAY_LIST_FEATURE"); - if(implementations && isModuleEnabled("LinkedList")) addKeyFlag("LINKED_LIST_FEATURE"); - if(implementations && isModuleEnabled("ImmutableList")) addKeyFlag("IMMUTABLE_LIST_FEATURE"); - if(implementations && isModuleEnabled("CopyOnWriteList")) addKeyFlag("COPY_ON_WRITE_LIST_FEATURE"); + if(MODULE.isEnabled()) addKeyFlag("LIST_MODULE"); + if(WRAPPERS.isEnabled()) addKeyFlag("LISTS_FEATURE"); + if(ARRAY_LIST.isEnabled()) addKeyFlag("ARRAY_LIST_FEATURE"); + if(LINKED_LIST.isEnabled()) addKeyFlag("LINKED_LIST_FEATURE"); + if(IMMUTABLE_LIST.isEnabled()) addKeyFlag("IMMUTABLE_LIST_FEATURE"); + if(COPY_ON_WRITE_LIST.isEnabled()) addKeyFlag("COPY_ON_WRITE_LIST_FEATURE"); } @Override protected void loadBlockades() { - if(!isModuleEnabled("Wrappers")) addBlockedFiles("Lists"); - boolean implementations = !isModuleEnabled("Implementations"); - if(implementations || !isModuleEnabled("ArrayList")) addBlockedFiles("ArrayList"); - if(implementations || !isModuleEnabled("LinkedList")) addBlockedFiles("LinkedList"); - if(implementations || !isModuleEnabled("ImmutableList")) addBlockedFiles("ImmutableList"); - if(implementations || !isModuleEnabled("CopyOnWriteList")) addBlockedFiles("CopyOnWriteList"); - if(!isModuleEnabled()) addBlockedFiles("List", "AbstractList"); + if(!WRAPPERS.isEnabled()) addBlockedFiles("Lists"); + if(!ARRAY_LIST.isEnabled()) addBlockedFiles("ArrayList"); + if(!LINKED_LIST.isEnabled()) addBlockedFiles("LinkedList"); + if(!IMMUTABLE_LIST.isEnabled()) addBlockedFiles("ImmutableList"); + if(!COPY_ON_WRITE_LIST.isEnabled()) addBlockedFiles("CopyOnWriteList"); + if(!MODULE.isEnabled()) addBlockedFiles("List", "AbstractList"); + if(keyType.isObject()) addBlockedFiles("ListFillBufferTester"); if(keyType == ClassType.BOOLEAN) addBlockedFiles("ListFillBufferTester", "ListReplaceAllTester"); } - @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) { - return new TreeSet<>(Arrays.asList("Implementations", "Wrappers", "ArrayList", "LinkedList", "ImmutableList", "CopyOnWriteList")); - } - - @Override - public boolean areDependenciesLoaded() { - return isDependencyLoaded(CollectionModule.INSTANCE); - } + @Override protected void loadRemappers() diff --git a/src/builder/java/speiger/src/builder/modules/MapModule.java b/src/builder/java/speiger/src/builder/modules/MapModule.java index f8a4f0e..41dba85 100644 --- a/src/builder/java/speiger/src/builder/modules/MapModule.java +++ b/src/builder/java/speiger/src/builder/modules/MapModule.java @@ -1,15 +1,44 @@ package speiger.src.builder.modules; +import java.util.ArrayList; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class MapModule extends BaseModule { public static final BaseModule INSTANCE = new MapModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true) + .addKeyDependency(SetModule.MODULE) + .addValueDependency(CollectionModule.MODULE) + .addEntryDependency(SetModule.MODULE) + .addTypeDependency(SetModule.MODULE, ClassType.OBJECT); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers").addKeyDependency(SetModule.WRAPPERS).addOptionalTypeDependency(SetModule.WRAPPERS, ClassType.OBJECT, true); + + public static final FunctionDependency ORDERED_MAP = MODULE.createDependency("OrderedMap").addKeyDependency(SetModule.ORDERED_SET).addOptionalTypeDependency(SetModule.ORDERED_SET, ClassType.OBJECT, true); + public static final FunctionDependency SORTED_MAP = MODULE.createDependency("SortedMap").addKeyDependency(SetModule.SORTED_SET).addOptionalTypeDependency(SetModule.SORTED_SET, ClassType.OBJECT, true); + + public static final FunctionDependency ARRAY_MAP = MODULE.createDependency("ArrayMap").addEntryDependency(ORDERED_MAP).addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_MAP = MODULE.createDependency("ImmutableMap").addEntryDependency(IMPLEMENTATION); + + public static final FunctionDependency HASH_MAP = MODULE.createDependency("HashMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_MAP = MODULE.createDependency("LinkedHashMap").addEntryDependency(HASH_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency CUSTOM_MAP = MODULE.createDependency("CustomHashMap").addEntryDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY); + public static final FunctionDependency LINKED_CUSTOM_MAP = MODULE.createDependency("LinkedCustomHashMap").addEntryDependency(CUSTOM_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency ENUM_MAP = MODULE.createDependency("EnumMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_ENUM_MAP = MODULE.createDependency("LinkedEnumMap").addEntryDependency(ENUM_MAP).addEntryDependency(ORDERED_MAP); + + public static final FunctionDependency CONCURRENT_MAP = MODULE.createDependency("ConcurrentMap").addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency AVL_TREE_MAP = MODULE.createDependency("AVLTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION); + public static final FunctionDependency RB_TREE_MAP = MODULE.createDependency("RBTreeMap").addEntryDependency(SORTED_MAP).addEntryDependency(IMPLEMENTATION); @Override public String getModuleName() { return "Map"; } @@ -20,79 +49,52 @@ public class MapModule extends BaseModule @Override public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; } @Override - public boolean areDependenciesLoaded() { return isDependencyLoaded(SetModule.INSTANCE) && isDependencyLoaded(CollectionModule.INSTANCE, false); } - - @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) { - Set sets = new TreeSet<>(); - sets.addAll(Arrays.asList("Wrappers", "Implementations")); - sets.addAll(Arrays.asList("OrderedMap", "SortedMap")); - sets.addAll(Arrays.asList("ArrayMap", "ConcurrentMap", "ImmutableMap")); - sets.addAll(Arrays.asList("HashMap", "LinkedHashMap")); - sets.addAll(Arrays.asList("CustomHashMap", "LinkedCustomHashMap")); - sets.addAll(Arrays.asList("EnumMap", "LinkedEnumMap")); - sets.addAll(Arrays.asList("AVLTreeMap", "RBTreeMap")); - return sets; + public List getDependencies(ClassType keyType, ClassType valueType) { + List dependencies = new ArrayList<>(Arrays.asList(MODULE, ORDERED_MAP, SORTED_MAP, IMPLEMENTATION, WRAPPERS, ARRAY_MAP, IMMUTABLE_MAP, HASH_MAP, LINKED_MAP, CUSTOM_MAP, LINKED_CUSTOM_MAP, CONCURRENT_MAP, AVL_TREE_MAP, RB_TREE_MAP)); + if(keyType == ClassType.OBJECT) dependencies.addAll(Arrays.asList(ENUM_MAP, LINKED_ENUM_MAP)); + return dependencies; } @Override protected void loadFlags() { - if(isModuleEnabled()) addFlag("MAP_MODULE"); - if(isModuleEnabled("Wrappers")) addFlag("MAPS_FEATURE"); - boolean implementations = isModuleEnabled("Implementations"); - boolean hashMap = implementations && isModuleEnabled("HashMap"); - boolean customHashMap = implementations && isModuleEnabled("CustomHashMap"); - boolean enumMap = implementations && isModuleEnabled("EnumMap"); + if(MODULE.isEnabled()) addFlag("MAP_MODULE"); + if(WRAPPERS.isEnabled()) addFlag("MAPS_FEATURE"); + if(ORDERED_MAP.isEnabled()) addFlag("ORDERED_MAP_FEATURE"); + if(ARRAY_MAP.isEnabled()) addFlag("ARRAY_MAP_FEATURE"); + if(LINKED_MAP.isEnabled()) addFlag("LINKED_MAP_FEATURE"); + if(LINKED_CUSTOM_MAP.isEnabled()) addFlag("LINKED_CUSTOM_MAP_FEATURE"); + if(LINKED_ENUM_MAP.isEnabled()) addFlag("LINKED_ENUM_MAP_FEATURE"); - if(isModuleEnabled("OrderedMap")) { - addFlag("ORDERED_MAP_FEATURE"); - if(isModuleEnabled("ArrayMap")) addFlag("ARRAY_MAP_FEATURE"); - if(hashMap && isModuleEnabled("LinkedHashMap")) addFlag("LINKED_MAP_FEATURE"); - if(customHashMap && isModuleEnabled("LinkedCustomHashMap")) addFlag("LINKED_CUSTOM_MAP_FEATURE"); - if(enumMap && isModuleEnabled("LinkedEnumMap")) addFlag("LINKED_ENUM_MAP_FEATURE"); - } - if(isModuleEnabled("SortedMap")) { - addFlag("SORTED_MAP_FEATURE"); - if(implementations && isModuleEnabled("AVLTreeMap")) addFlag("AVL_TREE_MAP_FEATURE"); - if(implementations && isModuleEnabled("RBTreeMap")) addFlag("RB_TREE_MAP_FEATURE"); - } - if(implementations && isModuleEnabled("ConcurrentMap")) addFlag("CONCURRENT_MAP_FEATURE"); - if(implementations && isModuleEnabled("ImmutableMap")) addFlag("IMMUTABLE_MAP_FEATURE"); - if(hashMap) addFlag("MAP_FEATURE"); - if(customHashMap) addFlag("CUSTOM_MAP_FEATURE"); - if(enumMap) addFlag("ENUM_MAP_FEATURE"); + if(SORTED_MAP.isEnabled()) addFlag("SORTED_MAP_FEATURE"); + if(AVL_TREE_MAP.isEnabled()) addFlag("AVL_TREE_MAP_FEATURE"); + if(RB_TREE_MAP.isEnabled()) addFlag("RB_TREE_MAP_FEATURE"); + + if(CONCURRENT_MAP.isEnabled()) addFlag("CONCURRENT_MAP_FEATURE"); + if(IMMUTABLE_MAP.isEnabled()) addFlag("IMMUTABLE_MAP_FEATURE"); + if(HASH_MAP.isEnabled()) addFlag("MAP_FEATURE"); + if(CUSTOM_MAP.isEnabled()) addFlag("CUSTOM_MAP_FEATURE"); + if(ENUM_MAP.isEnabled()) addFlag("ENUM_MAP_FEATURE"); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) addBlockedFiles("Map", "AbstractMap"); - if(!isModuleEnabled("Wrappers")) addBlockedFiles("Maps"); - boolean implementations = !isModuleEnabled("Implementations"); - if(implementations || !isModuleEnabled("ImmutableMap")) addBlockedFiles("ImmutableOpenHashMap"); - if(implementations || !isModuleEnabled("ConcurrentMap")) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap"); - - boolean ordered = !isModuleEnabled("OrderedMap"); - if(ordered) addBlockedFiles("OrderedMap"); - boolean hashMap = implementations || !isModuleEnabled("HashMap"); - if(hashMap) addBlockedFiles("OpenHashMap"); - if(hashMap || ordered || !isModuleEnabled("LinkedHashMap")) addBlockedFiles("LinkedOpenHashMap"); - - boolean customHashMap = implementations || !isModuleEnabled("CustomHashMap"); - if(customHashMap) addBlockedFiles("OpenCustomHashMap"); - if(customHashMap || ordered || !isModuleEnabled("LinkedCustomHashMap")) addBlockedFiles("LinkedOpenCustomHashMap"); - - boolean enumMap = implementations || !isModuleEnabled("EnumMap"); - if(enumMap) addBlockedFiles("EnumMap"); - if(enumMap || ordered || !isModuleEnabled("LinkedEnumMap")) addBlockedFiles("LinkedEnumMap"); - - if(ordered || !isModuleEnabled("ArrayMap")) addBlockedFiles("ArrayMap"); - - boolean sorted = !isModuleEnabled("SortedMap"); - if(sorted) addBlockedFiles("SortedMap", "NavigableMap"); - if(implementations || sorted || !isModuleEnabled("AVLTreeMap")) addBlockedFiles("AVLTreeMap"); - if(implementations || sorted || !isModuleEnabled("RBTreeMap")) addBlockedFiles("RBTreeMap"); + if(!MODULE.isEnabled()) addBlockedFiles("Map", "AbstractMap"); + if(!WRAPPERS.isEnabled()) addBlockedFiles("Maps"); + if(!IMMUTABLE_MAP.isEnabled()) addBlockedFiles("ImmutableOpenHashMap"); + if(!CONCURRENT_MAP.isEnabled()) addBlockedFiles("ConcurrentMap", "ConcurrentOpenHashMap"); + if(!ORDERED_MAP.isEnabled()) addBlockedFiles("OrderedMap"); + if(!HASH_MAP.isEnabled()) addBlockedFiles("OpenHashMap"); + if(!LINKED_MAP.isEnabled()) addBlockedFiles("LinkedOpenHashMap"); + if(!CUSTOM_MAP.isEnabled()) addBlockedFiles("OpenCustomHashMap"); + if(!LINKED_CUSTOM_MAP.isEnabled()) addBlockedFiles("LinkedOpenCustomHashMap"); + if(!ENUM_MAP.isEnabled()) addBlockedFiles("EnumMap"); + if(!LINKED_ENUM_MAP.isEnabled()) addBlockedFiles("LinkedEnumMap"); + if(!ARRAY_MAP.isEnabled()) addBlockedFiles("ArrayMap"); + if(!SORTED_MAP.isEnabled()) addBlockedFiles("SortedMap", "NavigableMap"); + if(!AVL_TREE_MAP.isEnabled()) addBlockedFiles("AVLTreeMap"); + if(!RB_TREE_MAP.isEnabled()) addBlockedFiles("RBTreeMap"); if(keyType == ClassType.BOOLEAN) { @@ -251,6 +253,7 @@ public class MapModule extends BaseModule //Abstract Classes addAbstractBiMapper("ABSTRACT_MAP", "Abstract%sMap", "2"); + addAbstractBiMapper("REVERSED_ORDERED_MAP", "Reversed%sOrderedMap", "2"); //Helper Classes addBiClassMapper("MAPS", "Maps", "2"); diff --git a/src/builder/java/speiger/src/builder/modules/PairModule.java b/src/builder/java/speiger/src/builder/modules/PairModule.java index b17efbc..473fa40 100644 --- a/src/builder/java/speiger/src/builder/modules/PairModule.java +++ b/src/builder/java/speiger/src/builder/modules/PairModule.java @@ -1,15 +1,26 @@ package speiger.src.builder.modules; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class PairModule extends BaseModule { public static final BaseModule INSTANCE = new PairModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, true).addKeyDependency(JavaModule.MODULE); + public static final FunctionDependency IMMUTABLE = MODULE.createDependency("Immutable"); + public static final FunctionDependency MUTABLE = MODULE.createDependency("Mutable"); + + +// public static final DependencyModule MODULE = new BiTypeModule(INSTANCE); +// public static final DependencyFunction IMMUTABLE = MODULE.createFunction("Immutable"); +// public static final DependencyFunction MUTABLE = MODULE.createFunction("Mutable"); + @Override public String getModuleName() { return "Pair"; } @Override @@ -21,20 +32,20 @@ public class PairModule extends BaseModule @Override protected void loadTestClasses() {} @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) { return new TreeSet<>(Arrays.asList("Mutable", "Immutable")); } + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, IMMUTABLE, MUTABLE); } @Override protected void loadFlags() { - if(isModuleEnabled()) addFlag("PAIR_MODULE"); - if(isModuleEnabled("Mutable")) addFlag("MUTABLE_PAIR"); - if(isModuleEnabled("Immutable")) addFlag("IMMUTABLE_PAIR"); + if(MODULE.isEnabled()) addFlag("PAIR_MODULE"); + if(MUTABLE.isEnabled()) addFlag("MUTABLE_PAIR"); + if(IMMUTABLE.isEnabled()) addFlag("IMMUTABLE_PAIR"); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) addBlockedFiles("Pair"); - if(!isModuleEnabled("Mutable")) addBlockedFiles("MutablePair"); - if(!isModuleEnabled("Immutable")) addBlockedFiles("ImmutablePair"); + if(!MODULE.isEnabled()) addBlockedFiles("Pair"); + if(!MUTABLE.isEnabled()) addBlockedFiles("MutablePair"); + if(!IMMUTABLE.isEnabled()) addBlockedFiles("ImmutablePair"); } @Override diff --git a/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java b/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java index d8cba68..5489693 100644 --- a/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java +++ b/src/builder/java/speiger/src/builder/modules/PrioQueueModule.java @@ -1,15 +1,26 @@ package speiger.src.builder.modules; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class PrioQueueModule extends BaseModule { public static final BaseModule INSTANCE = new PrioQueueModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency DEQUEUE = MODULE.createDependency("Dequeue"); + + public static final FunctionDependency FIFO_QUEUE = MODULE.createDependency("FiFoQueue").addKeyDependency(DEQUEUE).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency HEAP_QUEUE = MODULE.createDependency("HeapQueue").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency ARRAY_PRIO_QUEUE = MODULE.createDependency("ArrayPrioQueue").addKeyDependency(IMPLEMENTATION); + @Override public String getModuleName() { return "PriorityQueue"; } @@ -18,36 +29,26 @@ public class PrioQueueModule extends BaseModule @Override protected void loadFunctions() {} @Override - public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); } - - @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) { - return new TreeSet<>(Arrays.asList("Wrappers", "Implementations", "Dequeue", "FiFoQueue", "HeapQueue", "ArrayPrioQueue")); - } + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, WRAPPERS, IMPLEMENTATION, DEQUEUE, FIFO_QUEUE, HEAP_QUEUE, ARRAY_PRIO_QUEUE); } @Override protected void loadFlags() { - if(isModuleEnabled()) addFlag("QUEUE_MODULE"); - if(isModuleEnabled("Wrappers")) addKeyFlag("QUEUES_FEATURE"); - boolean implementations = isModuleEnabled("Implementations"); - if(isModuleEnabled("Dequeue")) { - addKeyFlag("DEQUEUE_FEATURE"); - if(implementations && isModuleEnabled("FiFoQueue")) addKeyFlag("FIFO_QUEUE_FEATURE"); - } - if(implementations && isModuleEnabled("HeapQueue")) addKeyFlag("HEAP_QUEUE_FEATURE"); - if(implementations && isModuleEnabled("ArrayPrioQueue")) addKeyFlag("ARRAY_QUEUE_FEATURE"); + if(MODULE.isEnabled()) addFlag("QUEUE_MODULE"); + if(WRAPPERS.isEnabled()) addKeyFlag("QUEUES_FEATURE"); + if(DEQUEUE.isEnabled()) addKeyFlag("DEQUEUE_FEATURE"); + if(FIFO_QUEUE.isEnabled()) addKeyFlag("FIFO_QUEUE_FEATURE"); + if(HEAP_QUEUE.isEnabled()) addKeyFlag("HEAP_QUEUE_FEATURE"); + if(ARRAY_PRIO_QUEUE.isEnabled()) addKeyFlag("ARRAY_QUEUE_FEATURE"); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) addBlockedFiles("PriorityQueue", "AbstractPriorityQueue"); - if(!isModuleEnabled("Wrappers")) addBlockedFiles("PriorityQueues"); - boolean implementations = !isModuleEnabled("Implementations"); - boolean dequeue = !isModuleEnabled("Dequeue"); - if(dequeue) addBlockedFiles("PriorityDequeue"); - if(dequeue || implementations || !isModuleEnabled("FiFoQueue")) addBlockedFiles("ArrayFIFOQueue"); - if(implementations || !isModuleEnabled("HeapQueue")) addBlockedFiles("HeapPriorityQueue"); - if(implementations || !isModuleEnabled("ArrayPrioQueue")) addBlockedFiles("ArrayPriorityQueue"); + if(!MODULE.isEnabled()) addBlockedFiles("PriorityQueue", "AbstractPriorityQueue"); + if(!WRAPPERS.isEnabled()) addBlockedFiles("PriorityQueues"); + if(!DEQUEUE.isEnabled()) addBlockedFiles("PriorityDequeue"); + if(!FIFO_QUEUE.isEnabled()) addBlockedFiles("ArrayFIFOQueue"); + if(!HEAP_QUEUE.isEnabled()) addBlockedFiles("HeapPriorityQueue"); + if(!ARRAY_PRIO_QUEUE.isEnabled()) addBlockedFiles("ArrayPriorityQueue"); if(keyType == ClassType.BOOLEAN) { addBlockedFiles("QueueTests"); diff --git a/src/builder/java/speiger/src/builder/modules/SetModule.java b/src/builder/java/speiger/src/builder/modules/SetModule.java index 1d7bba8..68d5c3d 100644 --- a/src/builder/java/speiger/src/builder/modules/SetModule.java +++ b/src/builder/java/speiger/src/builder/modules/SetModule.java @@ -1,15 +1,30 @@ package speiger.src.builder.modules; import java.util.Arrays; -import java.util.Set; -import java.util.TreeSet; +import java.util.List; import speiger.src.builder.ClassType; +import speiger.src.builder.dependencies.FunctionDependency; +import speiger.src.builder.dependencies.IDependency; +import speiger.src.builder.dependencies.ModuleDependency; @SuppressWarnings("javadoc") public class SetModule extends BaseModule { public static final BaseModule INSTANCE = new SetModule(); + public static final ModuleDependency MODULE = new ModuleDependency(INSTANCE, false).addKeyDependency(CollectionModule.MODULE).addKeyDependency(CollectionModule.SPLIT_ITERATORS); + public static final FunctionDependency IMPLEMENTATION = MODULE.createDependency("Implementations"); + public static final FunctionDependency WRAPPERS = MODULE.createDependency("Wrappers"); + public static final FunctionDependency ORDERED_SET = MODULE.createDependency("OrderedSet"); + public static final FunctionDependency SORTED_SET = MODULE.createDependency("SortedSet"); + public static final FunctionDependency ARRAY_SET = MODULE.createDependency("ArraySet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency IMMUTABLE_SET = MODULE.createDependency("ImmutableSet").addKeyDependency(ORDERED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency HASH_SET = MODULE.createDependency("HashSet").addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency LINKED_SET = MODULE.createDependency("LinkedHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(HASH_SET); + public static final FunctionDependency CUSTOM_SET = MODULE.createDependency("CustomHashSet").addKeyDependency(IMPLEMENTATION).addKeyDependency(CollectionModule.STRATEGY); + public static final FunctionDependency LINKED_CUSTOM_SET = MODULE.createDependency("LinkedCustomHashSet").addKeyDependency(ORDERED_SET).addKeyDependency(CUSTOM_SET); + public static final FunctionDependency AVL_TREE_SET = MODULE.createDependency("AVLTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION); + public static final FunctionDependency RB_TREE_SET = MODULE.createDependency("RBTreeSet").addKeyDependency(SORTED_SET).addKeyDependency(IMPLEMENTATION); @Override public String getModuleName() { return "Set"; } @@ -19,68 +34,40 @@ public class SetModule extends BaseModule @Override public boolean isModuleValid(ClassType keyType, ClassType valueType) { return keyType != ClassType.BOOLEAN; } @Override - public boolean areDependenciesLoaded() { return isDependencyLoaded(CollectionModule.INSTANCE); } - @Override - public Set getModuleKeys(ClassType keyType, ClassType valueType) { - Set sets = new TreeSet<>(); - sets.addAll(Arrays.asList("Wrappers", "Implementations")); - sets.addAll(Arrays.asList("OrderedSet", "SortedSet")); - sets.addAll(Arrays.asList("ArraySet", "ImmutableSet")); - sets.addAll(Arrays.asList("HashSet", "LinkedHashSet")); - sets.addAll(Arrays.asList("CustomHashSet", "LinkedCustomHashSet")); - sets.addAll(Arrays.asList("AVLTreeSet", "RBTreeSet")); - return sets; - } + public List getDependencies(ClassType keyType, ClassType valueType) { return Arrays.asList(MODULE, WRAPPERS, ORDERED_SET, SORTED_SET, IMPLEMENTATION, ARRAY_SET, IMMUTABLE_SET, HASH_SET, LINKED_SET, CUSTOM_SET, LINKED_CUSTOM_SET, AVL_TREE_SET, RB_TREE_SET); } @Override protected void loadFlags() { - if(isModuleEnabled()) addFlag("SET_MODULE"); - if(isModuleEnabled("Wrappers")) addFlag("SETS_FEATURE"); - boolean implementations = isModuleEnabled("Implementations"); - boolean hashSet = implementations && isModuleEnabled("HashSet"); - boolean customHashSet = implementations && isModuleEnabled("CustomHashSet"); - - if(isModuleEnabled("OrderedSet")) { - addFlag("ORDERED_SET_FEATURE"); - if(implementations && isModuleEnabled("ArraySet")) addFlag("ARRAY_SET_FEATURE"); - if(hashSet && isModuleEnabled("LinkedHashSet")) addFlag("LINKED_SET_FEATURE"); - if(customHashSet && isModuleEnabled("LinkedCustomHashSet")) addFlag("LINKED_CUSTOM_SET_FEATURE"); - } - if(isModuleEnabled("SortedSet")) { - addFlag("SORTED_SET_FEATURE"); - if(implementations && isModuleEnabled("AVLTreeSet")) addFlag("AVL_TREE_SET_FEATURE"); - if(implementations && isModuleEnabled("RBTreeSet")) addFlag("RB_TREE_SET_FEATURE"); - } - if(implementations && isModuleEnabled("ImmutableSet")) addFlag("IMMUTABLE_SET_FEATURE"); - if(hashSet) addFlag("HASH_SET_FEATURE"); - if(customHashSet) addFlag("CUSTOM_HASH_SET_FEATURE"); + if(MODULE.isEnabled()) addFlag("SET_MODULE"); + if(WRAPPERS.isEnabled()) addFlag("SETS_FEATURE"); + if(ORDERED_SET.isEnabled()) addFlag("ORDERED_SET_FEATURE"); + if(SORTED_SET.isEnabled()) addFlag("SORTED_SET_FEATURE"); + if(IMMUTABLE_SET.isEnabled()) addFlag("IMMUTABLE_SET_FEATURE"); + if(ARRAY_SET.isEnabled()) addFlag("ARRAY_SET_FEATURE"); + if(HASH_SET.isEnabled()) addFlag("HASH_SET_FEATURE"); + if(LINKED_SET.isEnabled()) addFlag("LINKED_SET_FEATURE"); + if(CUSTOM_SET.isEnabled()) addFlag("CUSTOM_HASH_SET_FEATURE"); + if(LINKED_CUSTOM_SET.isEnabled()) addFlag("LINKED_CUSTOM_SET_FEATURE"); + if(AVL_TREE_SET.isEnabled()) addFlag("AVL_TREE_SET_FEATURE"); + if(RB_TREE_SET.isEnabled()) addFlag("RB_TREE_SET_FEATURE"); } @Override protected void loadBlockades() { - if(!isModuleEnabled()) addBlockedFiles("Set", "AbstractSet"); - if(!isModuleEnabled("Wrappers")) addBlockedFiles("Sets"); - boolean implementations = !isModuleEnabled("Implementations"); - if(implementations || !isModuleEnabled("ImmutableSet")) addBlockedFiles("ImmutableOpenHashSet"); - - boolean ordered = !isModuleEnabled("OrderedSet"); - if(ordered) addBlockedFiles("OrderedSet"); - boolean hashSet = implementations || !isModuleEnabled("HashSet"); - if(hashSet) addBlockedFiles("OpenHashSet"); - if(hashSet || ordered || !isModuleEnabled("LinkedHashSet")) addBlockedFiles("LinkedOpenHashSet"); - - boolean customHashSet = implementations || !isModuleEnabled("CustomHashSet"); - if(customHashSet) addBlockedFiles("OpenCustomHashSet"); - if(customHashSet || ordered || !isModuleEnabled("LinkedCustomHashSet")) addBlockedFiles("LinkedOpenCustomHashSet"); - - if(implementations || ordered || !isModuleEnabled("ArraySet")) addBlockedFiles("ArraySet"); - - boolean sorted = !isModuleEnabled("SortedSet"); - if(sorted) addBlockedFiles("SortedSet", "NavigableSet"); - if(implementations || sorted || !isModuleEnabled("AVLTreeSet")) addBlockedFiles("AVLTreeSet"); - if(implementations || sorted || !isModuleEnabled("RBTreeSet")) addBlockedFiles("RBTreeSet"); + if(!MODULE.isEnabled()) addBlockedFiles("Set", "AbstractSet"); + if(!WRAPPERS.isEnabled()) addBlockedFiles("Sets"); + if(!IMMUTABLE_SET.isEnabled()) addBlockedFiles("ImmutableOpenHashSet"); + if(!ORDERED_SET.isEnabled()) addBlockedFiles("OrderedSet"); + if(!HASH_SET.isEnabled()) addBlockedFiles("OpenHashSet"); + if(!LINKED_SET.isEnabled()) addBlockedFiles("LinkedOpenHashSet"); + if(!CUSTOM_SET.isEnabled()) addBlockedFiles("OpenCustomHashSet"); + if(!LINKED_CUSTOM_SET.isEnabled()) addBlockedFiles("LinkedOpenCustomHashSet"); + if(!ARRAY_SET.isEnabled()) addBlockedFiles("ArraySet"); + if(!SORTED_SET.isEnabled()) addBlockedFiles("SortedSet", "NavigableSet"); + if(!AVL_TREE_SET.isEnabled()) addBlockedFiles("AVLTreeSet"); + if(!RB_TREE_SET.isEnabled()) addBlockedFiles("RBTreeSet"); if(keyType == ClassType.BOOLEAN) { @@ -161,6 +148,7 @@ public class SetModule extends BaseModule //Abstract Classes addAbstractMapper("ABSTRACT_SET", "Abstract%sSet"); + addAbstractMapper("REVERSED_ORDERED_SET", "Reversed%sOrderedSet"); //Helper Classes addClassMapper("SETS", "Sets"); diff --git a/src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template b/src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template index 78680e1..00775a0 100644 --- a/src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template +++ b/src/builder/resources/speiger/assets/collections/templates/collections/AbstractCollection.template @@ -1,12 +1,18 @@ package speiger.src.collections.PACKAGE.collections; import java.util.Collection; +#if ORDERED_MAP_FEATURE +import java.util.function.Supplier; +#endif import java.util.Objects; import java.util.AbstractCollection; #if TYPE_OBJECT import java.util.function.Consumer; #endif +#if ORDERED_MAP_FEATURE +import speiger.src.collections.PACKAGE.lists.LIST_ITERATOR; +#endif #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.functions.CONSUMER; 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; 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 reverseIterator; + + public REVERSED_ORDERED_COLLECTION(ORDERED_COLLECTION KEY_GENERIC_TYPE collection, Supplier 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 } \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template b/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template index 73ea018..7937a6e 100644 --- a/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template +++ b/src/builder/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template @@ -1,19 +1,11 @@ package speiger.src.collections.PACKAGE.collections; -#if !TYPE_OBJECT -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; -/** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing - */ -public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE, ObjectBidirectionalIterator -#else /** * This is a basically a {@link java.util.ListIterator} without the index functions. * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. * @Type(T) */ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE -#endif { /** * Returns true if the Iterator has a Previous element @@ -29,11 +21,11 @@ public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE public KEY_TYPE PREVIOUS(); #if !TYPE_OBJECT - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default CLASS_TYPE previous() { return KEY_TO_OBJ(PREVIOUS()); diff --git a/src/builder/resources/speiger/assets/collections/templates/collections/OrderedCollection.template b/src/builder/resources/speiger/assets/collections/templates/collections/OrderedCollection.template new file mode 100644 index 0000000..0cb1845 --- /dev/null +++ b/src/builder/resources/speiger/assets/collections/templates/collections/OrderedCollection.template @@ -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 { +#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 +} \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template b/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template index 54a1143..029a8c7 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/AbstractList.template @@ -11,11 +11,15 @@ import java.util.RandomAccess; import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION; import speiger.src.collections.PACKAGE.collections.COLLECTION; import speiger.src.collections.PACKAGE.collections.ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif #if INT_LIST_MODULE && !TYPE_INT import speiger.src.collections.ints.lists.IntList; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif import speiger.src.collections.utils.SanityChecks; /** @@ -532,9 +536,10 @@ public abstract class ABSTRACT_LIST KEY_GENERIC_TYPE extends ABSTRACT_COLLECTION public int size() { return size; } - +#if SPLIT_ITERATOR_FEATURE @Override public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 16464); } +#endif @Override public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index) { diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template b/src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template index c469a52..d37e82a 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/CopyOnWriteList.template @@ -535,7 +535,7 @@ public class COPY_ON_WRITE_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENER * @return if the element was found. */ @Override - @Deprecated + @Primitive public boolean contains(Object o) { 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) */ @Override - @Deprecated + @Primitive public int indexOf(Object o) { KEY_TYPE[] data = this.data; #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) */ @Override - @Deprecated + @Primitive public int lastIndexOf(Object o) { KEY_TYPE[] data = this.data; #if TYPE_OBJECT diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template b/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template index b8d336b..722e8ee 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/LinkedList.template @@ -13,11 +13,13 @@ import java.util.Collection; import java.util.Iterator; import java.util.Objects; import java.util.NoSuchElementException; +#if SPLIT_ITERATOR_FEATURE import java.util.Spliterator; #if PRIMITIVES import java.util.Spliterator.JAVA_SPLIT_ITERATOR; #endif import java.util.function.Consumer; +#endif import java.util.function.Predicate; #if TYPE_OBJECT import java.util.function.IntFunction; @@ -60,12 +62,14 @@ import speiger.src.collections.objects.utils.ObjectArrays; #if TYPE_OBJECT import speiger.src.collections.utils.Stack; #endif +#if SPLIT_ITERATOR_FEATURE #if PRIMITIVES import java.util.stream.JAVA_STREAM; import java.util.stream.StreamSupport; #endif import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif import speiger.src.collections.utils.SanityChecks; /** @@ -415,7 +419,8 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + +#if SPLIT_ITERATOR_FEATURE #if PRIMITIVES /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. @@ -436,6 +441,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE @Override public SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return new TypeSplitIteratorBRACES(this, first, 0); } +#endif @Override public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { Objects.requireNonNull(action); @@ -1253,6 +1259,7 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE } } +#if SPLIT_ITERATOR_FEATURE private static class TypeSplitIterator KEY_GENERIC_TYPE implements SPLIT_ITERATOR KEY_GENERIC_TYPE { static final int BATCH_UNIT = 1 << 10; @@ -1397,4 +1404,5 @@ public class LINKED_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE } } #endif +#endif } \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/lists/List.template b/src/builder/resources/speiger/assets/collections/templates/lists/List.template index 3443086..4aa195e 100644 --- a/src/builder/resources/speiger/assets/collections/templates/lists/List.template +++ b/src/builder/resources/speiger/assets/collections/templates/lists/List.template @@ -15,7 +15,10 @@ import java.util.function.UnaryOperator; #endif import speiger.src.collections.PACKAGE.collections.COLLECTION; +import speiger.src.collections.PACKAGE.collections.ORDERED_COLLECTION; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif import speiger.src.collections.ints.functions.consumer.BI_FROM_INT_CONSUMER; #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.functions.COMPARATOR; @@ -27,7 +30,9 @@ import speiger.src.collections.PACKAGE.utils.LISTS; #if INT_LIST_MODULE && !TYPE_INT import speiger.src.collections.ints.lists.IntList; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if TYPE_BYTE || TYPE_SHORT || TYPE_CHAR || TYPE_FLOAT import speiger.src.collections.utils.SanityChecks; #endif @@ -36,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 * @Type(T) */ -public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List +public interface LIST KEY_GENERIC_TYPE extends ORDERED_COLLECTION KEY_GENERIC_TYPE, List { #if !TYPE_OBJECT /** @@ -101,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); + /** + * 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. * This function was introduced due to how annoying it is to get/remove the last element of a list. @@ -504,9 +527,56 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List @Override @Deprecated 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} + *

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} + *

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} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -554,7 +624,7 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List @Override @Deprecated public default boolean contains(Object o) { - return COLLECTION.super.contains(o); + return ORDERED_COLLECTION.super.contains(o); } /** {@inheritDoc} @@ -564,7 +634,7 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List @Override @Deprecated public default boolean remove(Object o) { - return COLLECTION.super.remove(o); + return ORDERED_COLLECTION.super.remove(o); } /** {@inheritDoc} @@ -594,10 +664,12 @@ public interface LIST KEY_GENERIC_TYPE extends COLLECTION KEY_GENERIC_TYPE, List } #endif #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif } \ No newline at end of file diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template index 29e0b4d..91fb553 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/abstracts/AbstractMap.template @@ -14,6 +14,15 @@ import speiger.src.collections.PACKAGE.functions.function.FUNCTION; #endif import speiger.src.collections.PACKAGE.functions.function.UNARY_OPERATOR; import speiger.src.collections.PACKAGE.maps.interfaces.MAP; +#if ORDERED_MAP_FEATURE +import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP; +import speiger.src.collections.PACKAGE.sets.ORDERED_SET; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; +#if !TYPE_OBJECT +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +#endif +#endif import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.SET; #if MAPS_FEATURE @@ -42,7 +51,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap implements MAP KEY_VALUE_GENERIC_TYPE { - protected VALUE_TYPE defaultReturnValue = EMPTY_VALUE; + protected VALUE_TYPE defaultReturnValue = INVALID_VALUE; @Override public VALUE_TYPE getDefaultReturnValue() { @@ -119,7 +128,7 @@ public abstract class ABSTRACT_MAP KEY_VALUE_GENERIC_TYPE extends AbstractMap ENTRY_SET() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.ENTRY_SET()); } + @Override + public ORDERED_SET KEY_GENERIC_TYPE keySet() { return new ABSTRACT_SET.REVERSED_ORDERED_SETBRACES(map.keySet()); } + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { return map.values().reversed(); } + @Override + public ORDERED_MAP KEY_VALUE_GENERIC_TYPE reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @Type(T) diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template index 1003644..3f3f2bc 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/customHash/LinkedOpenCustomHashMap.template @@ -40,7 +40,7 @@ import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.ORDERED_SET; import speiger.src.collections.PACKAGE.utils.STRATEGY; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; -import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR; #if !SAME_TYPE import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; @@ -295,6 +295,54 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M return getDefaultReturnValue(); } + @Override + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { + if(strategy.equals(key, EMPTY_KEY_VALUE)) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(strategy.hashCode(key)) & mask; + while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToFirstIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + + @Override + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { + if(strategy.equals(key, EMPTY_KEY_VALUE)) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(strategy.hashCode(key)) & mask; + while(!strategy.equals(keys[pos], EMPTY_KEY_VALUE)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(KEY_TYPE key) { if(isEmpty() || strategy.equals(FIRST_ENTRY_KEY(), key)) return false; @@ -430,6 +478,52 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M return values[lastIndex]; } + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) { + containsNull = false; + keys[nullIndex] = EMPTY_KEY_VALUE; + values[nullIndex] = EMPTY_VALUE; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + if(strategy.equals(result.ENTRY_KEY(), EMPTY_KEY_VALUE)) { + containsNull = false; + keys[nullIndex] = EMPTY_KEY_VALUE; + values[nullIndex] = EMPTY_VALUE; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet ENTRY_SET() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -443,9 +537,9 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } @Override - public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC; } @Override @@ -630,24 +724,24 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); POLL_FIRST_ENTRY_KEY(); return entry; } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); POLL_LAST_ENTRY_KEY(); return entry; @@ -655,7 +749,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -665,7 +764,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -919,7 +1018,12 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new KeyIterator(false); } @Override @@ -941,22 +1045,22 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_FIRST_KEY() { + public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_LAST_KEY() { + public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } @@ -1100,39 +1204,47 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } } - private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE { + private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE { #if VALUE_OBJECT @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } #else @Override - public boolean contains(VALUE_TYPE e) { - return containsValue(e); - } - + public boolean contains(VALUE_TYPE e) { return containsValue(e); } #endif @Override - public boolean add(VALUE_TYPE o) { - throw new UnsupportedOperationException(); - } - + public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); } @Override - public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { - return new ValueIterator(); - } - + public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); } @Override - public int size() { - return LINKED_CUSTOM_HASH_MAP.this.size(); - } - + public int size() { return LINKED_CUSTOM_HASH_MAP.this.size(); } @Override - public void clear() { - LINKED_CUSTOM_HASH_MAP.this.clear(); + public void clear() { LINKED_CUSTOM_HASH_MAP.this.clear(); } + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); } + private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { + VALUE_TYPE result = FIRST_ENTRY_VALUE(); + POLL_FIRST_ENTRY_KEY(); + return result; + } + @Override + public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { + VALUE_TYPE result = LAST_ENTRY_VALUE(); + POLL_LAST_ENTRY_KEY(); + return result; } @Override @@ -1278,7 +1390,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(KEY_TYPE from) { super(from); } @@ -1305,7 +1417,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(KEY_TYPE from) { super(from); } @@ -1335,7 +1447,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(KEY_TYPE from) { super(from); } @@ -1357,7 +1469,7 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public VALUE_TYPE VALUE_PREVIOUS() { @@ -1378,16 +1490,20 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(KEY_TYPE from) { + this.forward = true; if(strategy.equals(from, EMPTY_KEY_VALUE)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1415,11 +1531,11 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1479,20 +1595,30 @@ public class LINKED_CUSTOM_HASH_MAP KEY_VALUE_GENERIC_TYPE extends CUSTOM_HASH_M public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template index ceded47..3ac8a24 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/hash/LinkedOpenHashMap.template @@ -39,7 +39,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP; import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.ORDERED_SET; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; -import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR; #if !SAME_TYPE import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; @@ -272,6 +272,54 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G return getDefaultReturnValue(); } + @Override + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { + if(KEY_EQUALS_NULL(key)) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask; + while(KEY_EQUALS_NULL(key)) { + if(KEY_EQUALS(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToFirstIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + + @Override + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { + if(KEY_EQUALS_NULL(key)) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(KEY_TO_HASH(key)) & mask; + while(KEY_EQUALS_NULL(key)) { + if(KEY_EQUALS(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(KEY_TYPE key) { if(isEmpty() || KEY_EQUALS(FIRST_ENTRY_KEY(), key)) return false; @@ -434,6 +482,52 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G return values[lastIndex]; } + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + if(KEY_EQUALS_NULL(result.ENTRY_KEY())) { + containsNull = false; + keys[nullIndex] = EMPTY_KEY_VALUE; + values[nullIndex] = EMPTY_VALUE; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + if(KEY_EQUALS_NULL(result.ENTRY_KEY())) { + containsNull = false; + keys[nullIndex] = EMPTY_KEY_VALUE; + values[nullIndex] = EMPTY_VALUE; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet ENTRY_SET() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -447,9 +541,9 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } @Override - public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC; } @Override @@ -634,24 +728,24 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); POLL_FIRST_ENTRY_KEY(); return entry; } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); POLL_LAST_ENTRY_KEY(); return entry; @@ -659,7 +753,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -669,7 +768,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -918,7 +1017,12 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new KeyIterator(false); } @Override @@ -940,22 +1044,22 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_FIRST_KEY() { + public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_LAST_KEY() { + public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } @@ -1099,41 +1203,50 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } } - private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE { + private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE { #if VALUE_OBJECT @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } #else @Override - public boolean contains(VALUE_TYPE e) { - return containsValue(e); - } + public boolean contains(VALUE_TYPE e) { return containsValue(e); } #endif @Override - public boolean add(VALUE_TYPE o) { - throw new UnsupportedOperationException(); - } - + public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); } @Override - public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { - return new ValueIterator(); - } - + public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); } @Override - public int size() { - return LINKED_HASH_MAP.this.size(); - } - + public int size() { return LINKED_HASH_MAP.this.size(); } @Override - public void clear() { - LINKED_HASH_MAP.this.clear(); + public void clear() { LINKED_HASH_MAP.this.clear(); } + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); } + private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { + VALUE_TYPE result = FIRST_ENTRY_VALUE(); + POLL_FIRST_ENTRY_KEY(); + return result; + } + @Override + public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { + VALUE_TYPE result = LAST_ENTRY_VALUE(); + POLL_LAST_ENTRY_KEY(); + return result; } - @Override public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { Objects.requireNonNull(action); @@ -1278,7 +1391,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(KEY_TYPE from) { super(from); } @@ -1305,7 +1418,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(KEY_TYPE from) { super(from); } @@ -1335,7 +1448,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(KEY_TYPE from) { super(from); } @@ -1357,7 +1470,7 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public VALUE_TYPE VALUE_PREVIOUS() { @@ -1377,13 +1490,16 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(KEY_TYPE from) { @@ -1414,11 +1530,11 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1478,20 +1594,30 @@ public class LINKED_HASH_MAP KEY_VALUE_GENERIC_TYPE extends HASH_MAP KEY_VALUE_G public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template index 1191936..3434913 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/immutable/ImmutableOpenHashMap.template @@ -65,7 +65,7 @@ import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_PREDICATE; import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; #endif import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; -import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR; import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER; #if !SAME_TYPE @@ -119,7 +119,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ /** KeySet cache */ protected transient ORDERED_SET KEY_GENERIC_TYPE keySet; /** Values cache */ - protected transient VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC; + protected transient VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -320,6 +320,10 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ @Override public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } @Override + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); } @@ -441,7 +445,24 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ public VALUE_TYPE LAST_ENTRY_VALUE() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet ENTRY_SET() { @@ -456,7 +477,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } @Override - public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -621,24 +642,29 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ public boolean moveToLast(MAP.Entry KEY_VALUE_GENERIC_TYPE o) { throw new UnsupportedOperationException(); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -648,7 +674,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -875,7 +901,12 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new KeyIterator(false); } @Override @@ -895,20 +926,20 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ public void clear() { throw new UnsupportedOperationException(); } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); } @Override public void forEach(CONSUMER KEY_SUPER_GENERIC_TYPE action) { @@ -1050,39 +1081,42 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } } - private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE { + private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE { #if VALUE_OBJECT @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } #else @Override - public boolean contains(VALUE_TYPE e) { - return containsValue(e); - } + public boolean contains(VALUE_TYPE e) { return containsValue(e); } #endif @Override - public boolean add(VALUE_TYPE o) { - throw new UnsupportedOperationException(); - } - + public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); } @Override - public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { - return new ValueIterator(); - } - + public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); } @Override - public int size() { - return IMMUTABLE_HASH_MAP.this.size(); - } - + public int size() { return IMMUTABLE_HASH_MAP.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); } + private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); } @Override public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { int index = firstIndex; @@ -1226,7 +1260,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(KEY_TYPE from) { super(from); } @@ -1252,7 +1286,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(KEY_TYPE from) { super(from); } @@ -1279,7 +1313,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(KEY_TYPE from) { super(from); } @@ -1301,7 +1335,7 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public VALUE_TYPE VALUE_PREVIOUS() { @@ -1322,13 +1356,16 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(KEY_TYPE from) { @@ -1359,11 +1396,11 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1417,30 @@ public class IMMUTABLE_HASH_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_ public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template index 9e08ec7..6a678b4 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/ArrayMap.template @@ -46,7 +46,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP; import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.ORDERED_SET; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; -import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR; import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_SUPPLIER; #if !SAME_TYPE @@ -105,7 +105,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN /** KeySet cache */ protected ORDERED_SET KEY_GENERIC_TYPE keySet; /** Values cache */ - protected VALUE_COLLECTION VALUE_GENERIC_TYPE valuesC; + protected VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE valuesC; /** EntrySet cache */ protected FastOrderedSet KEY_VALUE_GENERIC_TYPE entrySet; @@ -275,6 +275,27 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN return lastValue; } + @Override + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(KEY_TYPE key) { int index = findIndex(key); @@ -402,6 +423,34 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN return result; } + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[0], values[0]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[size-1], values[size-1]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public VALUE_TYPE REMOVE_VALUE(KEY_TYPE key) { int index = findIndex(key); @@ -461,7 +510,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } @Override - public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -828,24 +877,24 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); POLL_FIRST_ENTRY_KEY(); return entry; } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); POLL_LAST_ENTRY_KEY(); return entry; @@ -853,7 +902,12 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -863,7 +917,7 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -1073,7 +1127,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN @Override public boolean moveToLast(KEY_TYPE o) { return ARRAY_MAP.this.moveToLast(o); } @Override - public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(); } + public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { return new KeyIterator(true); } + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { return new KeyIterator(false); } @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { return new KeyIterator(fromElement); } @Override @@ -1081,13 +1137,13 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN @Override public void clear() { ARRAY_MAP.this.clear(); } @Override - public KEY_TYPE FIRST_KEY() { return FIRST_ENTRY_KEY(); } + public KEY_TYPE GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } + public KEY_TYPE REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } @Override - public KEY_TYPE LAST_KEY() { return LAST_ENTRY_KEY(); } + public KEY_TYPE GET_LAST_KEY() { return LAST_ENTRY_KEY(); } @Override - public KEY_TYPE POLL_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } + public KEY_TYPE REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1197,40 +1253,49 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } } - private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE { + private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE { #if VALUE_OBJECT @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } #else @Override - public boolean contains(VALUE_TYPE e) { - return containsValue(e); - } + public boolean contains(VALUE_TYPE e) { return containsValue(e); } #endif @Override - public boolean add(VALUE_TYPE o) { - throw new UnsupportedOperationException(); - } - + public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); } @Override - public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { - return new ValueIterator(); - } - + public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); } @Override - public int size() { - return ARRAY_MAP.this.size(); - } - + public int size() { return ARRAY_MAP.this.size(); } @Override - public void clear() { - ARRAY_MAP.this.clear(); + public void clear() { ARRAY_MAP.this.clear(); } + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); } + private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { + VALUE_TYPE result = FIRST_ENTRY_VALUE(); + POLL_FIRST_ENTRY_KEY(); + return result; + } + @Override + public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { + VALUE_TYPE result = LAST_ENTRY_VALUE(); + POLL_LAST_ENTRY_KEY(); + return result; } - @Override public void forEach(VALUE_CONSUMER VALUE_SUPER_GENERIC_TYPE action) { Objects.requireNonNull(action); @@ -1332,10 +1397,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(KEY_TYPE from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(KEY_TYPE element) { super(element); } @Override public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { @@ -1358,11 +1421,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(KEY_TYPE from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(KEY_TYPE element) { super(element); } @Override public MAP.Entry KEY_VALUE_GENERIC_TYPE next() { @@ -1389,11 +1449,8 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { - public KeyIterator() {} - public KeyIterator(KEY_TYPE element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(KEY_TYPE element) { super(element); } @Override public KEY_TYPE PREVIOUS() { @@ -1413,6 +1470,9 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(KEY_TYPE element) { super(element); } + @Override public VALUE_TYPE VALUE_PREVIOUS() { return values[previousEntry()]; @@ -1431,23 +1491,37 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(KEY_TYPE element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1460,26 +1534,42 @@ public class ARRAY_MAP KEY_VALUE_GENERIC_TYPE extends ABSTRACT_MAP KEY_VALUE_GEN public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template index 82ba166..35a913a 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/impl/misc/LinkedEnumMap.template @@ -18,7 +18,7 @@ import speiger.src.collections.PACKAGE.maps.interfaces.ORDERED_MAP; import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET; import speiger.src.collections.PACKAGE.sets.ORDERED_SET; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ABSTRACT_COLLECTION; -import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_COLLECTION; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ITERATOR; #if !VALUE_OBJECT && !SAME_TYPE import speiger.src.collections.VALUE_PACKAGE.functions.VALUE_CONSUMER; @@ -216,6 +216,28 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA return getDefaultReturnValue(); } + @Override + public VALUE_TYPE putFirst(T key, VALUE_TYPE value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public VALUE_TYPE putLast(T key, VALUE_TYPE value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -312,6 +334,42 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA return values[lastIndex]; } + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[firstIndex], values[firstIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntryKV_BRACES(keys[lastIndex], values[lastIndex]); + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE; + return result; + } + + @Override + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry KEY_VALUE_GENERIC_TYPE result = new BasicEntryKV_BRACES(keys[pos], values[pos]); + size--; + values[result.ENTRY_KEY().ordinal()] = EMPTY_VALUE; + return result; + } + @Override public ObjectOrderedSet ENTRY_SET() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -325,9 +383,9 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } @Override - public VALUE_COLLECTION VALUE_GENERIC_TYPE values() { + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE)valuesC; } @Override @@ -431,24 +489,24 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(FIRST_ENTRY_KEY(), FIRST_ENTRY_VALUE()); POLL_FIRST_ENTRY_KEY(); return entry; } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { BasicEntry KEY_VALUE_GENERIC_TYPE entry = new BasicEntryKV_BRACES(LAST_ENTRY_KEY(), LAST_ENTRY_VALUE()); POLL_LAST_ENTRY_KEY(); return entry; @@ -456,7 +514,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -466,7 +529,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -593,7 +656,12 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new KeyIterator(false); } @Override @@ -614,22 +682,22 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } @Override - public T FIRST_KEY() { + public T GET_FIRST_KEY() { return FIRST_ENTRY_KEY(); } @Override - public T POLL_FIRST_KEY() { + public T REMOVE_FIRST_KEY() { return POLL_FIRST_ENTRY_KEY(); } @Override - public T LAST_KEY() { + public T GET_LAST_KEY() { return LAST_ENTRY_KEY(); } @Override - public T POLL_LAST_KEY() { + public T REMOVE_LAST_KEY() { return POLL_LAST_ENTRY_KEY(); } @@ -656,41 +724,50 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA #endif } - private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE { + private class Values extends VALUE_ABSTRACT_COLLECTION VALUE_GENERIC_TYPE implements VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE { #if VALUE_OBJECT @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } #else @Override - public boolean contains(VALUE_TYPE e) { - return containsValue(e); - } + public boolean contains(VALUE_TYPE e) { return containsValue(e); } #endif @Override - public boolean add(VALUE_TYPE o) { - throw new UnsupportedOperationException(); - } - + public boolean add(VALUE_TYPE o) { throw new UnsupportedOperationException(); } @Override - public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { - return new ValueIterator(); - } - + public VALUE_ITERATOR VALUE_GENERIC_TYPE iterator() { return new ValueIterator(true); } @Override - public int size() { - return LINKED_ENUM_MAP.this.size(); - } - + public int size() { return LINKED_ENUM_MAP.this.size(); } @Override - public void clear() { - LINKED_ENUM_MAP.this.clear(); + public void clear() { LINKED_ENUM_MAP.this.clear(); } + @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE reversed() { return new VALUE_ABSTRACT_COLLECTION.VALUE_REVERSED_ORDERED_COLLECTIONVALUE_BRACES(this, this::reverseIterator); } + private VALUE_ITERATOR VALUE_GENERIC_TYPE reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(VALUE_TYPE e) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE VALUE_GET_FIRST_KEY() { return FIRST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_FIRST_KEY() { + VALUE_TYPE result = FIRST_ENTRY_VALUE(); + POLL_FIRST_ENTRY_KEY(); + return result; + } + @Override + public VALUE_TYPE VALUE_GET_LAST_KEY() { return LAST_ENTRY_VALUE(); } + @Override + public VALUE_TYPE VALUE_REMOVE_LAST_KEY() { + VALUE_TYPE result = LAST_ENTRY_VALUE(); + POLL_LAST_ENTRY_KEY(); + return result; } - #if VALUE_OBJECT @Override public void forEach(Consumer VALUE_SUPER_GENERIC_TYPE action) { @@ -715,7 +792,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -742,7 +819,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -772,7 +849,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA private class KeyIterator extends MapIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -794,7 +871,7 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } private class ValueIterator extends MapIterator implements VALUE_LIST_ITERATOR VALUE_GENERIC_TYPE { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public VALUE_TYPE VALUE_PREVIOUS() { @@ -815,16 +892,20 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -832,11 +913,11 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -871,20 +952,30 @@ public class LINKED_ENUM_MAP KEY_ENUM_VALUE_GENERIC_TYPE extends ENUM_MAP KEY_VA public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template b/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template index 08adcf2..c073c8a 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/Map.template @@ -154,7 +154,7 @@ public interface MAP KEY_VALUE_GENERIC_TYPE extends Map entry) { - return put(entry.getKey(), entry.getValue()); + return put(OBJ_TO_KEY(entry.getKey()), OBJ_TO_VALUE(entry.getValue())); } #endif diff --git a/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template b/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template index 1882661..074329f 100644 --- a/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template +++ b/src/builder/resources/speiger/assets/collections/templates/maps/interfaces/OrderedMap.template @@ -1,8 +1,15 @@ package speiger.src.collections.PACKAGE.maps.interfaces; +#if JAVA_VERSION>=21 +import java.util.Map; +import java.util.SequencedMap; + +#endif #if MAPS_FEATURE import speiger.src.collections.PACKAGE.utils.maps.MAPS; #endif +import speiger.src.collections.PACKAGE.maps.abstracts.ABSTRACT_MAP; +import speiger.src.collections.VALUE_PACKAGE.collections.VALUE_ORDERED_COLLECTION; #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.sets.ORDERED_SET; #endif @@ -17,7 +24,11 @@ import speiger.src.collections.objects.sets.ObjectOrderedSet; * @Type(T) * @ValueType(V) */ +#if JAVA_VERSION>=21 +public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE, SequencedMap +#else public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERIC_TYPE +#endif { /** * A customized put method that allows you to insert into the first index. @@ -37,6 +48,26 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI */ public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value); + /** + * A alternative to putAndMoveToFirst. + * This method simply puts an entry at the first spot of the Map but only if the entry is missing. + * @param key the key that should be inserted + * @param value the value that should be inserted + * @return the previous present or default return value + * @see java.util.Map#put(Object, Object) + */ + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value); + + /** + * A alternative to putAndMoveToLast. + * This method simply puts an entry at the last spot of the Map but only if the entry is missing. + * @param key the key that should be inserted + * @param value the value that should be inserted + * @return the previous present or default return value + * @see java.util.Map#put(Object, Object) + */ + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -97,13 +128,34 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI */ public VALUE_TYPE LAST_ENTRY_VALUE(); + @Java21 + public MAP.Entry KEY_VALUE_GENERIC_TYPE firstEntry(); + @Java21 + public MAP.Entry KEY_VALUE_GENERIC_TYPE lastEntry(); + @Java21 + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirstEntry(); + @Java21 + public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLastEntry(); @Override public ORDERED_MAP KEY_VALUE_GENERIC_TYPE copy(); @Override public ORDERED_SET KEY_GENERIC_TYPE keySet(); @Override + public VALUE_ORDERED_COLLECTION VALUE_GENERIC_TYPE values(); + @Override public ObjectOrderedSet 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> sequencedEntrySet() { return (ObjectOrderedSet>)(Object)ENTRY_SET(); } + +#endif #if MAPS_FEATURE /** * Creates a Wrapped SortedMap that is Synchronized @@ -130,6 +182,22 @@ public interface ORDERED_MAP KEY_VALUE_GENERIC_TYPE extends MAP KEY_VALUE_GENERI @Override public default ORDERED_MAP KEY_VALUE_GENERIC_TYPE unmodifiable() { return MAPS.unmodifiable(this); } +#endif +#if JAVA_VERSION>=21 +#if !SAME_TYPE || !TYPE_OBJECT + @Override + @Deprecated + public default CLASS_VALUE_TYPE putFirst(CLASS_TYPE k, CLASS_VALUE_TYPE v) { + return putFirst(OBJ_TO_KEY(k), OBJ_TO_VALUE(v)); + } + + @Override + @Deprecated + public default CLASS_VALUE_TYPE putLast(CLASS_TYPE k, CLASS_VALUE_TYPE v) { + return putLast(OBJ_TO_KEY(k), OBJ_TO_VALUE(v)); + } + +#endif #endif /** * Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template index bc97fff..468c4b8 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/AbstractSet.template @@ -6,6 +6,7 @@ import java.util.Objects; import java.util.Set; import speiger.src.collections.PACKAGE.collections.ABSTRACT_COLLECTION; +import speiger.src.collections.PACKAGE.collections.BI_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; } } + +#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 } diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template b/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template index 01fa4dc..bcffc7f 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/ArraySet.template @@ -219,13 +219,13 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im #endif @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -354,7 +354,7 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im #endif @Override - public KEY_TYPE POLL_FIRST_KEY() { + public KEY_TYPE REMOVE_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); KEY_TYPE result = data[0]; 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 - public KEY_TYPE POLL_LAST_KEY() { + public KEY_TYPE REMOVE_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); size--; #if TYPE_OBJECT @@ -511,13 +511,18 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new SetIterator(false, size); } @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -570,45 +575,57 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im } private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public KEY_TYPE NEXT() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public KEY_TYPE PREVIOUS() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -637,15 +654,23 @@ public class ARRAY_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERIC_TYPE im @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template index 0128ee9..73f00a8 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/ImmutableOpenHashSet.template @@ -285,22 +285,22 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); } @Override 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 public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new SetIterator(false); } @Override @@ -521,16 +526,20 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI } private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(KEY_TYPE from) { + this.forward = true; if(KEY_EQUALS_NULL(from)) { if(containsNull) { next = (int) links[nullIndex]; @@ -559,48 +568,60 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -609,8 +630,8 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI @Override public KEY_TYPE PREVIOUS() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -618,12 +639,22 @@ public class IMMUTABLE_HASH_SET KEY_GENERIC_TYPE extends ABSTRACT_SET KEY_GENERI @Override public KEY_TYPE NEXT() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template index ba5282f..90876dd 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenCustomHashSet.template @@ -291,7 +291,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override 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(containsNull) { moveToFirstIndex(nullIndex); @@ -313,7 +313,7 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override 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(containsNull) { moveToLastIndex(nullIndex); @@ -370,13 +370,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public KEY_TYPE POLL_FIRST_KEY() { + public KEY_TYPE REMOVE_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -392,13 +392,13 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public KEY_TYPE POLL_LAST_KEY() { + public KEY_TYPE REMOVE_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -697,7 +697,12 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new SetIterator(false); } @Override @@ -722,16 +727,20 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY } private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(KEY_TYPE from) { + this.forward = true; if(strategy.equals(from, EMPTY_KEY_VALUE)) { if(containsNull) { next = (int) links[nullIndex]; @@ -760,48 +769,60 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -850,8 +871,8 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override public KEY_TYPE PREVIOUS() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -859,12 +880,22 @@ public class LINKED_CUSTOM_HASH_SET KEY_GENERIC_TYPE extends CUSTOM_HASH_SET KEY @Override public KEY_TYPE NEXT() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template index 9ebffa8..ff8c356 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/LinkedOpenHashSet.template @@ -262,7 +262,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override 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(containsNull) { moveToFirstIndex(nullIndex); @@ -284,7 +284,7 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override 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(containsNull) { moveToLastIndex(nullIndex); @@ -341,13 +341,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE } @Override - public KEY_TYPE FIRST_KEY() { + public KEY_TYPE GET_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public KEY_TYPE POLL_FIRST_KEY() { + public KEY_TYPE REMOVE_FIRST_KEY() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -363,13 +363,13 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE } @Override - public KEY_TYPE LAST_KEY() { + public KEY_TYPE GET_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public KEY_TYPE POLL_LAST_KEY() { + public KEY_TYPE REMOVE_LAST_KEY() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -668,7 +668,12 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override public LIST_ITERATOR KEY_GENERIC_TYPE iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE reverseIterator() { + return new SetIterator(false); } @Override @@ -693,16 +698,20 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE } private class SetIterator implements LIST_ITERATOR KEY_GENERIC_TYPE { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(KEY_TYPE from) { + this.forward = true; if(KEY_EQUALS_NULL(from)) { if(containsNull) { next = (int) links[nullIndex]; @@ -731,48 +740,60 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -821,8 +842,8 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override public KEY_TYPE PREVIOUS() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -830,12 +851,22 @@ public class LINKED_HASH_SET KEY_GENERIC_TYPE extends HASH_SET KEY_GENERIC_TYPE @Override public KEY_TYPE NEXT() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template index eaa07b7..c215610 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/NavigableSet.template @@ -3,11 +3,13 @@ package speiger.src.collections.PACKAGE.sets; import java.util.NavigableSet; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** * A Type Specific Navigable Set interface with a couple helper methods @@ -145,6 +147,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet public default NAVIGABLE_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -152,6 +155,7 @@ public interface NAVIGABLE_SET KEY_GENERIC_TYPE extends NavigableSet @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif #if !TYPE_OBJECT @Override @Deprecated diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template index f98bf74..7a31a48 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/OrderedSet.template @@ -1,11 +1,18 @@ package speiger.src.collections.PACKAGE.sets; +#if JAVA_VERSION>=21 +import java.util.SequencedSet; + +#endif import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif +import speiger.src.collections.PACKAGE.sets.ABSTRACT_SET.REVERSED_ORDERED_SET; #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** * A Special Set Interface giving Access to some really usefull functions @@ -15,7 +22,11 @@ import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; * * @Type(T) */ +#if JAVA_VERSION>=21 +public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, SequencedSet +#else 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. @@ -52,6 +63,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator(); + public BI_ITERATOR KEY_GENERIC_TYPE reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -61,6 +73,7 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE */ public BI_ITERATOR KEY_GENERIC_TYPE iterator(KEY_TYPE fromElement); +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -68,27 +81,81 @@ public interface ORDERED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif /** * A method to get the 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 * @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 * @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 * @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} + *

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} + *

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} + *

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} + *

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} + *

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} + *

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 /** * Creates a Wrapped OrderedSet that is Synchronized diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/Set.template b/src/builder/resources/speiger/assets/collections/templates/sets/Set.template index a83e5c6..aa637d8 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/Set.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/Set.template @@ -4,11 +4,13 @@ import java.util.Set; import speiger.src.collections.PACKAGE.collections.COLLECTION; import speiger.src.collections.PACKAGE.collections.ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif -import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; /** @@ -88,10 +90,12 @@ public interface SET KEY_GENERIC_TYPE extends Set, COLLECTION KEY_GE public default SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } -} \ No newline at end of file +#endif +} diff --git a/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template b/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template index 01cc4f9..cc00ca5 100644 --- a/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template +++ b/src/builder/resources/speiger/assets/collections/templates/sets/SortedSet.template @@ -3,7 +3,9 @@ package speiger.src.collections.PACKAGE.sets; import java.util.SortedSet; import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.collections.SPLIT_ITERATOR; +#endif #if TYPE_OBJECT import java.util.Comparator; #else @@ -12,7 +14,9 @@ import speiger.src.collections.PACKAGE.functions.COMPARATOR; #if SETS_FEATURE import speiger.src.collections.PACKAGE.utils.SETS; #endif +#if SPLIT_ITERATOR_FEATURE import speiger.src.collections.PACKAGE.utils.SPLIT_ITERATORS; +#endif /** * A Type Specific SortedSet implementation to reduce boxing/unboxing @@ -67,6 +71,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte public default SORTED_SET KEY_GENERIC_TYPE unmodifiable() { return SETS.unmodifiable(this); } #endif +#if SPLIT_ITERATOR_FEATURE /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator @@ -74,6 +79,7 @@ public interface SORTED_SET KEY_GENERIC_TYPE extends SET KEY_GENERIC_TYPE, Sorte @Override default SPLIT_ITERATOR KEY_GENERIC_TYPE spliterator() { return SPLIT_ITERATORS.createSplititerator(this, 0); } +#endif #if !TYPE_OBJECT /** * A Type Specific SubSet method to reduce boxing/unboxing diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Collections.template b/src/builder/resources/speiger/assets/collections/templates/utils/Collections.template index f8a98a4..200f46c 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Collections.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Collections.template @@ -23,6 +23,9 @@ import java.util.function.Consumer; import speiger.src.collections.PACKAGE.collections.ABSTRACT_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; #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.functions.COMPARATOR; @@ -76,6 +79,37 @@ public class COLLECTIONS 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. * @param c that should be synchronized @@ -668,6 +702,38 @@ public class COLLECTIONS @Override 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 @@ -810,6 +876,34 @@ public class COLLECTIONS 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 * @Type(T) diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template b/src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template index d7b6c64..27ffc7e 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Iterables.template @@ -342,6 +342,8 @@ public class ITERABLES #argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction #argument APPLY test applyAsByte applyAsShort applyAsInt applyAsLong applyAsFloat applyAsDouble #argument DATA_TYPE Boolean Byte Short Int Long Float Double +#argument FILTER_TYPE BOOLEAN_COLLECTION_MODULE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE +#if FILTER_TYPE private static class MAPPED_TYPEIterable implements OUTPUT_ITERABLE, ISizeProvider { ITERABLE KEY_SPECIAL_GENERIC_TYPE iterable; @@ -369,6 +371,7 @@ public class ITERABLES } } +#endif #enditerate #endif private static class MappedIterable KSS_GENERIC_TYPE implements ObjectIterable, ISizeProvider diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template b/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template index dc71c85..c0b5da2 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Iterators.template @@ -25,7 +25,7 @@ import speiger.src.collections.booleans.collections.BooleanIterator; #argument PACKAGE bytes shorts ints longs floats doubles #argument MAPPER ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction #argument FILTER_TYPE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE -#if BOOLEAN_COLLECTION_MODULE +#if FILTER_TYPE import speiger.src.collections.objects.functions.function.MAPPER; import speiger.src.collections.PACKAGE.collections.ITERATOR; #endif @@ -65,7 +65,7 @@ public class ITERATORS * @Type(T) * @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 return (EmptyIterator)EMPTY; #else @@ -400,7 +400,7 @@ public class ITERATORS * @ArrayType(T) * @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); } @@ -412,7 +412,7 @@ public class ITERATORS * @ArrayType(T) * @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); } @@ -925,6 +925,8 @@ public class ITERATORS #argument MAPPER Predicate ToByteFunction ToShortFunction ToIntFunction ToLongFunction ToFloatFunction ToDoubleFunction #argument APPLY test applyAsByte applyAsShort applyAsInt applyAsLong applyAsFloat applyAsDouble #argument DATA_TYPE boolean byte short int long float double +#argument FILTER_TYPE BOOLEAN_COLLECTION_MODULE BYTE_COLLECTION_MODULE SHORT_COLLECTION_MODULE INT_COLLECTION_MODULE LONG_COLLECTION_MODULE FLOAT_COLLECTION_MODULE DOUBLE_COLLECTION_MODULE +#if FILTER_TYPE private static class MAPPED_TYPEIterator implements OUTPUT_ITERATOR { ITERATOR iterator; @@ -951,6 +953,7 @@ public class ITERATORS } } +#endif #enditerate #endif private static class FlatMappedIterator KSS_GENERIC_TYPE> implements ObjectIterator diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Lists.template b/src/builder/resources/speiger/assets/collections/templates/utils/Lists.template index f48adc3..8735d35 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Lists.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Lists.template @@ -45,7 +45,7 @@ public class LISTS * @Type(T) * @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 return (EmptyList)EMPTY; #else diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template b/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template index 14e62c0..78b0e8f 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/Sets.template @@ -371,17 +371,19 @@ public class SETS @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator() { return ITERATORS.unmodifiable(s.iterator()); } @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)); } @Override public ORDERED_SET KEY_GENERIC_TYPE copy() { return s.copy(); } @Override - public KEY_TYPE FIRST_KEY() { return s.FIRST_KEY(); } + public KEY_TYPE GET_FIRST_KEY() { return s.GET_FIRST_KEY(); } @Override - public KEY_TYPE POLL_FIRST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_FIRST_KEY() { throw new UnsupportedOperationException(); } @Override - public KEY_TYPE LAST_KEY() { return s.LAST_KEY(); } + public KEY_TYPE GET_LAST_KEY() { return s.GET_LAST_KEY(); } @Override - public KEY_TYPE POLL_LAST_KEY() { throw new UnsupportedOperationException(); } + public KEY_TYPE REMOVE_LAST_KEY() { throw new UnsupportedOperationException(); } } #endif @@ -660,17 +662,19 @@ public class SETS @Override public BI_ITERATOR KEY_GENERIC_TYPE iterator() { synchronized(mutex) { return s.iterator(); } } @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); } } @Override public ORDERED_SET KEY_GENERIC_TYPE copy() { synchronized(mutex) { return s.copy(); } } @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 - 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 - 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 - 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 diff --git a/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template b/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template index 2fa0854..6bf3db4 100644 --- a/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template +++ b/src/builder/resources/speiger/assets/collections/templates/utils/maps/Maps.template @@ -56,6 +56,9 @@ import speiger.src.collections.PACKAGE.sets.SET; import speiger.src.collections.PACKAGE.utils.SETS; #endif 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 import speiger.src.collections.VALUE_PACKAGE.functions.function.VALUE_UNARY_OPERATOR; #endif @@ -553,6 +556,10 @@ public class MAPS @Override public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } @Override + public VALUE_TYPE putFirst(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } + @Override + public VALUE_TYPE putLast(KEY_TYPE key, VALUE_TYPE value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(KEY_TYPE key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(KEY_TYPE key) { throw new UnsupportedOperationException(); } @@ -573,13 +580,25 @@ public class MAPS @Override public VALUE_TYPE LAST_ENTRY_VALUE() { return map.LAST_ENTRY_VALUE(); } @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(); } @Override public ORDERED_SET KEY_GENERIC_TYPE keySet() { if(keys == null) keys = SETS.unmodifiable(map.keySet()); 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 public ObjectOrderedSet ENTRY_SET() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySetKV_BRACES(map.ENTRY_SET()); @@ -749,15 +768,17 @@ public class MAPS @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(MAP.Entry KEY_VALUE_GENERIC_TYPE fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE first() { return set.first(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE getFirst() { return set.getFirst(); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollFirst() { throw new UnsupportedOperationException(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeFirst() { throw new UnsupportedOperationException(); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE last() { return set.last(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE getLast() { return set.getLast(); } @Override - public MAP.Entry KEY_VALUE_GENERIC_TYPE pollLast() { throw new UnsupportedOperationException(); } + public MAP.Entry KEY_VALUE_GENERIC_TYPE removeLast() { throw new UnsupportedOperationException(); } } #endif @@ -938,6 +959,10 @@ public class MAPS @Override public VALUE_TYPE putAndMoveToLast(KEY_TYPE key, VALUE_TYPE value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @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); } } @Override public boolean moveToLast(KEY_TYPE key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -958,13 +983,25 @@ public class MAPS @Override public VALUE_TYPE LAST_ENTRY_VALUE() { synchronized(mutex) { return map.LAST_ENTRY_VALUE(); } } @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(); } } @Override public ORDERED_SET KEY_GENERIC_TYPE keySet() { if(keys == null) keys = SETS.synchronize(map.keySet(), mutex); 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 public ObjectOrderedSet ENTRY_SET() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.ENTRY_SET(), mutex); diff --git a/src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template b/src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template index 247eba5..d2bbdfd 100644 --- a/src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template +++ b/src/builder/resources/speiger/assets/testers/templates/builder/OrderedSetTestSuiteBuilder.template @@ -1,16 +1,29 @@ package speiger.src.testers.PACKAGE.builder; +import java.util.ArrayList; +import java.util.Collection; import java.util.List; import com.google.common.collect.testing.AbstractTester; +import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder; import com.google.common.collect.testing.Helpers; +import com.google.common.collect.testing.OneSizeTestContainerGenerator; +import com.google.common.collect.testing.SampleElements; import com.google.common.collect.testing.features.CollectionFeature; +import com.google.common.collect.testing.features.Feature; import junit.framework.TestSuite; +import speiger.src.collections.PACKAGE.collections.ITERABLE; +import speiger.src.collections.PACKAGE.lists.ARRAY_LIST; +import speiger.src.collections.PACKAGE.lists.LIST; +import speiger.src.collections.PACKAGE.sets.ORDERED_SET; +import speiger.src.collections.PACKAGE.utils.LISTS; import speiger.src.testers.PACKAGE.generators.TEST_ORDERED_SET_GENERATOR; import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetMoveTester; import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetIterationTester; import speiger.src.testers.PACKAGE.tests.set.FILE_KEY_TYPEOrderedSetNavigationTester; +import speiger.src.testers.PACKAGE.utils.SAMPLE_ELEMENTS; +import speiger.src.testers.utils.SpecialFeature; @SuppressWarnings("javadoc") public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER KEY_GENERIC_TYPE { @@ -35,4 +48,68 @@ public class ORDERED_SET_TEST_BUILDER KEY_GENERIC_TYPE extends SET_TEST_BUILDER #endignore return super.createTestSuite(); } + + @Override + protected List createDerivedSuites( + FeatureSpecificTestSuiteBuilder, CLASS_TYPE>> parentBuilder) { + List derivedSuites = super.createDerivedSuites(parentBuilder); + + if (!parentBuilder.getFeatures().contains(SpecialFeature.REVERSE)) { + derivedSuites.add(createReverseSuite(parentBuilder)); + } + + return derivedSuites; + } + + private TestSuite createReverseSuite(FeatureSpecificTestSuiteBuilder, CLASS_TYPE>> parentBuilder) { + TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE delegate = (TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator(); + + List> features = new ArrayList<>(); + features.add(SpecialFeature.REVERSE); + features.addAll(parentBuilder.getFeatures()); + features.remove(SpecialFeature.COPYING); + features.remove(SpecialFeature.CHILDREN_COPY); + + return ORDERED_SET_TEST_BUILDER.using(new TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE() { + @Override + public SampleElements samples() { + return delegate.samples(); + } + + @Override + public SAMPLE_ELEMENTS KEY_GENERIC_TYPE getSamples() { + return delegate.getSamples(); + } + + @Override + public ITERABLE KEY_GENERIC_TYPE order(LIST KEY_GENERIC_TYPE insertionOrder) { + return insertionOrder; + } + + @Override + public Iterable order(List insertionOrder) { + return insertionOrder; + } + +#if !TYPE_OBJECT + @Override + public ORDERED_SET KEY_GENERIC_TYPE create(KEY_TYPE... elements) { + LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES(elements); + LISTS.reverse(list); + return delegate.create(list.TO_ARRAY()).reversed(); + } + +#endif + @Override + public ORDERED_SET KEY_GENERIC_TYPE create(Object... elements) { + LIST KEY_GENERIC_TYPE list = new ARRAY_LISTBRACES(); + for (Object e : elements) { + list.add(CLASS_TO_KEY(e)); + } + LISTS.reverse(list); + return delegate.create(list.toArray()).reversed(); + } + }).named(parentBuilder.getName() + " reversing").withFeatures(features) + .suppressing(parentBuilder.getSuppressedTests()).createTestSuite(); + } } diff --git a/src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template b/src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template index 74ea9fb..9b6bcec 100644 --- a/src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template +++ b/src/builder/resources/speiger/assets/testers/templates/builder/maps/MapTestSuiteBuilder.template @@ -238,21 +238,17 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder private static Set> computeEntrySetFeatures(Set> mapFeatures) { Set> entrySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures); #ignore - if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) { - entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); - } - if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) { - entrySetFeatures.add(SpecialFeature.COPYING); - } - else { - entrySetFeatures.remove(SpecialFeature.COPYING); - } - if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) { - entrySetFeatures.add(SpecialFeature.MODIFIABLE); - } - else { - entrySetFeatures.remove(SpecialFeature.MODIFIABLE); - } + if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); + + if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) entrySetFeatures.add(SpecialFeature.COPYING); + else entrySetFeatures.remove(SpecialFeature.COPYING); + + if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) entrySetFeatures.add(SpecialFeature.MODIFIABLE); + else entrySetFeatures.remove(SpecialFeature.MODIFIABLE); + + if(mapFeatures.contains(SpecialFeature.REVERSE)) entrySetFeatures.add(SpecialFeature.REVERSE); + else entrySetFeatures.remove(SpecialFeature.REVERSE); + entrySetFeatures.add(SpecialFeature.MAP_ENTRY); #endignore return entrySetFeatures; @@ -262,23 +258,17 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder Set> keySetFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures); #ignore keySetFeatures.add(CollectionFeature.SUBSET_VIEW); - if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) { - keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES); - } else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) { - keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); - } - if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) { - keySetFeatures.add(SpecialFeature.COPYING); - } - else { - keySetFeatures.remove(SpecialFeature.COPYING); - } - if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) { - keySetFeatures.add(SpecialFeature.MODIFIABLE); - } - else { - keySetFeatures.remove(SpecialFeature.MODIFIABLE); - } + if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES); + else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); + + if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) keySetFeatures.add(SpecialFeature.COPYING); + else keySetFeatures.remove(SpecialFeature.COPYING); + + if(mapFeatures.contains(SpecialFeature.MODIFIABLE)) keySetFeatures.add(SpecialFeature.MODIFIABLE); + else keySetFeatures.remove(SpecialFeature.MODIFIABLE); + + if(mapFeatures.contains(SpecialFeature.REVERSE)) keySetFeatures.add(SpecialFeature.REVERSE); + else keySetFeatures.remove(SpecialFeature.REVERSE); #endignore return keySetFeatures; } @@ -287,18 +277,15 @@ public class MAP_TEST_BUILDER KEY_VALUE_GENERIC_TYPE extends MapTestSuiteBuilder private static Set> computeValuesCollectionFeatures(Set> mapFeatures) { Set> valuesCollectionFeatures = MapTestSuiteBuilder.computeCommonDerivedCollectionFeatures(mapFeatures); #ignore - if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) { - valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); - } - if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) { - valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES); - } - if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) { - valuesCollectionFeatures.add(SpecialFeature.COPYING); - } - else { - valuesCollectionFeatures.remove(SpecialFeature.COPYING); - } + if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES); + + if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES); + + if(mapFeatures.contains(SpecialFeature.CHILDREN_COPY)) valuesCollectionFeatures.add(SpecialFeature.COPYING); + else valuesCollectionFeatures.remove(SpecialFeature.COPYING); + + if(mapFeatures.contains(SpecialFeature.REVERSE)) valuesCollectionFeatures.add(SpecialFeature.REVERSE); + else valuesCollectionFeatures.remove(SpecialFeature.REVERSE); #endignore return valuesCollectionFeatures; } diff --git a/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template b/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template index f47fbf2..5568ad5 100644 --- a/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template +++ b/src/builder/resources/speiger/assets/testers/templates/builder/maps/OrderedMapTestSuiteBuilder.template @@ -1,9 +1,14 @@ package speiger.src.testers.PACKAGE.builder.maps; +import java.util.ArrayList; import java.util.List; +import java.util.Map; 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.Feature; import junit.framework.TestSuite; 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_SET_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_TYPEOrderedMapNavigationTester; #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.generators.TestObjectOrderedSetGenerator; #endif +import speiger.src.testers.utils.SpecialFeature; @SuppressWarnings("javadoc") 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(); } + @Override + protected List createDerivedSuites(FeatureSpecificTestSuiteBuilder, Map.Entry>> parentBuilder) { + List derivedSuites = super.createDerivedSuites(parentBuilder); + if (!parentBuilder.getFeatures().contains(SpecialFeature.REVERSE)) { + derivedSuites.add(createReverseSuite(parentBuilder)); + } + return derivedSuites; + } + protected ObjectSetTestSuiteBuilder createDerivedEntrySetSuite(TestObjectSetGenerator entrySetGenerator) { return ObjectOrderedSetTestSuiteBuilder.using((TestObjectOrderedSetGenerator)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) { return ORDERED_SET_TEST_BUILDER.using((TEST_ORDERED_SET_GENERATOR KEY_GENERIC_TYPE)generator); } + + private TestSuite createReverseSuite(FeatureSpecificTestSuiteBuilder, Map.Entry>> parentBuilder) { + TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE delegate = (TEST_ORDERED_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE) parentBuilder.getSubjectGenerator().getInnerGenerator(); + + List> features = new ArrayList<>(); + features.add(SpecialFeature.REVERSE); + features.addAll(parentBuilder.getFeatures()); + features.remove(SpecialFeature.COPYING); + features.remove(SpecialFeature.CHILDREN_COPY); + return ORDERED_MAP_TEST_BUILDER.using(new DERIVED_MAP_GENERATORS.ReverseTestOrderedMapGenerator(delegate)) + .named(parentBuilder.getName() + " reversed").withFeatures(features) + .suppressing(parentBuilder.getSuppressedTests()).createTestSuite(); + } } diff --git a/src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template b/src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template index a8d141a..505d96e 100644 --- a/src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template +++ b/src/builder/resources/speiger/assets/testers/templates/impl/maps/DerivedMapGenerators.template @@ -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.Entry; 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; #if !TYPE_OBJECT import speiger.src.collections.PACKAGE.sets.SET; @@ -206,6 +207,22 @@ public class DERIVED_MAP_GENERATORS { } } + public static class ReverseTestOrderedMapGenerator 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 ReverseTestOrderedMapGenerator(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) { + ObjectList entries = new ObjectArrayList(elements); + ObjectLists.reverse(entries); + return ((ORDERED_MAP KEY_VALUE_GENERIC_TYPE)parent.create(entries.toArray(Entry[]::new))).reversed(); + } + } + public static class MapGenerator KEY_VALUE_GENERIC_TYPE implements TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE { TEST_MAP_GENERATOR KEY_VALUE_GENERIC_TYPE parent; diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template index 55f70f6..48d351d 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetMoveTester.template @@ -45,10 +45,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testaddMoveToFirstMissing() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertEquals(true, orderedSet.addAndMoveToFirst(e4())); - assertNotEquals(a, orderedSet.FIRST_KEY()); - assertEquals(e4(), orderedSet.FIRST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); + assertEquals(e4(), orderedSet.GET_FIRST_KEY()); } #ignore @@ -57,10 +57,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testaddMoveToFirstPreset() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertEquals(false, orderedSet.addAndMoveToFirst(c)); - assertNotEquals(a, orderedSet.FIRST_KEY()); - assertEquals(c, orderedSet.FIRST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); + assertEquals(c, orderedSet.GET_FIRST_KEY()); } #ignore @@ -69,10 +69,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testaddMoveToLastMissing() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertEquals(true, orderedSet.addAndMoveToLast(e4())); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(e4(), orderedSet.LAST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(e4(), orderedSet.GET_LAST_KEY()); } #ignore @@ -81,10 +81,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testaddMoveToLastPreset() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertEquals(false, orderedSet.addAndMoveToLast(a)); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(a, orderedSet.LAST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(a, orderedSet.GET_LAST_KEY()); } #ignore @@ -93,9 +93,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveToFirstMissing() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertEquals(false, orderedSet.moveToFirst(e4())); - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); } #ignore @@ -104,10 +104,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveToFirstPreset() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertEquals(true, orderedSet.moveToFirst(c)); - assertNotEquals(a, orderedSet.FIRST_KEY()); - assertEquals(c, orderedSet.FIRST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); + assertEquals(c, orderedSet.GET_FIRST_KEY()); } #ignore @@ -116,9 +116,9 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveToLastMissing() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertEquals(false, orderedSet.moveToLast(e4())); - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); } #ignore @@ -127,10 +127,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveToLastPreset() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertEquals(true, orderedSet.moveToLast(a)); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(a, orderedSet.LAST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(a, orderedSet.GET_LAST_KEY()); } #ignore @@ -139,10 +139,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveCenterToLast() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertTrue(orderedSet.moveToLast(e1())); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(e1(), orderedSet.LAST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(e1(), orderedSet.GET_LAST_KEY()); } #ignore @@ -151,10 +151,10 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveCenterToFirst() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertTrue(orderedSet.moveToFirst(e1())); - assertNotEquals(c, orderedSet.FIRST_KEY()); - assertEquals(e1(), orderedSet.FIRST_KEY()); + assertNotEquals(c, orderedSet.GET_FIRST_KEY()); + assertEquals(e1(), orderedSet.GET_FIRST_KEY()); } #ignore @@ -163,13 +163,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveForthAndBack() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertTrue(orderedSet.moveToLast(e0())); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(a, orderedSet.LAST_KEY()); - assertNotEquals(a, orderedSet.FIRST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(a, orderedSet.GET_LAST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); assertTrue(orderedSet.moveToFirst(e0())); - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); } #ignore @@ -178,13 +178,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testMoveBackAndForth() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertTrue(orderedSet.moveToFirst(e2())); - assertNotEquals(a, orderedSet.FIRST_KEY()); - assertEquals(c, orderedSet.FIRST_KEY()); - assertNotEquals(c, orderedSet.LAST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); + assertEquals(c, orderedSet.GET_FIRST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); assertTrue(orderedSet.moveToLast(e2())); - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); } #ignore @@ -193,13 +193,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testAddForthAndBack() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); assertFalse(orderedSet.addAndMoveToLast(e0())); - assertNotEquals(c, orderedSet.LAST_KEY()); - assertEquals(a, orderedSet.LAST_KEY()); - assertNotEquals(a, orderedSet.FIRST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); + assertEquals(a, orderedSet.GET_LAST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); assertFalse(orderedSet.addAndMoveToFirst(e0())); - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); } #ignore @@ -208,13 +208,13 @@ public class FILE_KEY_TYPEOrderedSetMoveTester KEY_GENERIC_TYPE extends ABSTRACT #endignore public void testAddBackAndForth() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); assertFalse(orderedSet.addAndMoveToFirst(e2())); - assertNotEquals(a, orderedSet.FIRST_KEY()); - assertEquals(c, orderedSet.FIRST_KEY()); - assertNotEquals(c, orderedSet.LAST_KEY()); + assertNotEquals(a, orderedSet.GET_FIRST_KEY()); + assertEquals(c, orderedSet.GET_FIRST_KEY()); + assertNotEquals(c, orderedSet.GET_LAST_KEY()); assertFalse(orderedSet.addAndMoveToLast(e2())); - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); } #ignore diff --git a/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template b/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template index 5b38428..70657dc 100644 --- a/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template +++ b/src/builder/resources/speiger/assets/testers/templates/tests/set/OrderedSetNavigationTester.template @@ -68,7 +68,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB int polled = 0; int expectedPolls = orderedSet.size(); while(polled < expectedPolls) { - orderedSet.POLL_FIRST_KEY(); + orderedSet.REMOVE_FIRST_KEY(); polled++; } 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 expectedPolls = orderedSet.size(); while(polled < expectedPolls) { - orderedSet.POLL_LAST_KEY(); + orderedSet.REMOVE_LAST_KEY(); polled++; } assertTrue("Map should be empty", orderedSet.isEmpty()); @@ -94,8 +94,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testEmptySetPollFirst() { try { - orderedSet.POLL_FIRST_KEY(); - fail("OrderedSet.POLL_FIRST_KEY should throw NoSuchElementException"); + orderedSet.REMOVE_FIRST_KEY(); + fail("OrderedSet.REMOVE_FIRST_KEY should throw NoSuchElementException"); } catch (NoSuchElementException e) { } expectUnchanged(); @@ -107,8 +107,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testEmptySetPollLast() { try { - orderedSet.POLL_LAST_KEY(); - fail("OrderedSet.POLL_LAST_KEY should throw NoSuchElementException"); + orderedSet.REMOVE_LAST_KEY(); + fail("OrderedSet.REMOVE_LAST_KEY should throw NoSuchElementException"); } catch (NoSuchElementException e) { } expectUnchanged(); @@ -119,8 +119,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testUnsupportedSetPollFirst() { try { - orderedSet.POLL_FIRST_KEY(); - fail("OrderedSet.POLL_FIRST_KEY should throw UnsupportedOperationException"); + orderedSet.REMOVE_FIRST_KEY(); + fail("OrderedSet.REMOVE_FIRST_KEY should throw UnsupportedOperationException"); } catch (UnsupportedOperationException e) { } expectUnchanged(); @@ -131,8 +131,8 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testUnsupportedSetPollLast() { try { - orderedSet.POLL_LAST_KEY(); - fail("OrderedSet.POLL_LAST_KEY should throw UnsupportedOperationException"); + orderedSet.REMOVE_LAST_KEY(); + fail("OrderedSet.REMOVE_LAST_KEY should throw UnsupportedOperationException"); } catch (UnsupportedOperationException e) { } expectUnchanged(); @@ -143,7 +143,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB @CollectionSize.Require(ONE) #endignore public void testSingletonSetPollFirst() { - assertEquals(a, orderedSet.POLL_FIRST_KEY()); + assertEquals(a, orderedSet.REMOVE_FIRST_KEY()); assertTrue(orderedSet.isEmpty()); } @@ -152,7 +152,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB @CollectionSize.Require(ONE) #endignore public void testSingletonSetPollLast() { - assertEquals(a, orderedSet.POLL_LAST_KEY()); + assertEquals(a, orderedSet.REMOVE_LAST_KEY()); assertTrue(orderedSet.isEmpty()); } @@ -161,7 +161,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB @CollectionSize.Require(SEVERAL) #endignore public void testPollFirst() { - assertEquals(a, orderedSet.POLL_FIRST_KEY()); + assertEquals(a, orderedSet.REMOVE_FIRST_KEY()); 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) #endignore 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)); } @@ -179,7 +179,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testPollFirstUnsupported() { try { - orderedSet.POLL_FIRST_KEY(); + orderedSet.REMOVE_FIRST_KEY(); fail(); } catch (UnsupportedOperationException e) { } @@ -190,7 +190,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testPollLastUnsupported() { try { - orderedSet.POLL_LAST_KEY(); + orderedSet.REMOVE_LAST_KEY(); fail(); } catch (UnsupportedOperationException e) { } @@ -201,7 +201,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testEmptySetFirst() { try { - orderedSet.FIRST_KEY(); + orderedSet.GET_FIRST_KEY(); fail(); } catch (NoSuchElementException e) { } @@ -212,7 +212,7 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB #endignore public void testEmptySetLast() { try { - orderedSet.LAST_KEY(); + orderedSet.GET_LAST_KEY(); fail(); } catch (NoSuchElementException e) { } @@ -222,27 +222,27 @@ public class FILE_KEY_TYPEOrderedSetNavigationTester KEY_GENERIC_TYPE extends AB @CollectionSize.Require(ONE) #endignore public void testSingletonSetFirst() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); } #ignore @CollectionSize.Require(ONE) #endignore public void testSingletonSetLast() { - assertEquals(a, orderedSet.LAST_KEY()); + assertEquals(a, orderedSet.GET_LAST_KEY()); } #ignore @CollectionSize.Require(SEVERAL) #endignore public void testFirst() { - assertEquals(a, orderedSet.FIRST_KEY()); + assertEquals(a, orderedSet.GET_FIRST_KEY()); } #ignore @CollectionSize.Require(SEVERAL) #endignore public void testLast() { - assertEquals(c, orderedSet.LAST_KEY()); + assertEquals(c, orderedSet.GET_LAST_KEY()); } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/booleans/collections/AbstractBooleanCollection.java b/src/main/java/speiger/src/collections/booleans/collections/AbstractBooleanCollection.java index ff61344..4c4a5ca 100644 --- a/src/main/java/speiger/src/collections/booleans/collections/AbstractBooleanCollection.java +++ b/src/main/java/speiger/src/collections/booleans/collections/AbstractBooleanCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.booleans.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.booleans.lists.BooleanListIterator; import speiger.src.collections.booleans.functions.BooleanConsumer; import speiger.src.collections.booleans.utils.BooleanIterators; import speiger.src.collections.booleans.utils.BooleanArrays; @@ -249,4 +251,68 @@ public abstract class AbstractBooleanCollection extends AbstractCollection size()) a[size()] = false; return a; } + + public static class ReverseBooleanOrderedCollection extends AbstractBooleanCollection implements BooleanOrderedCollection { + BooleanOrderedCollection collection; + Supplier reverseIterator; + + public ReverseBooleanOrderedCollection(BooleanOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(boolean o) { return collection.add(o); } + @Override + public BooleanOrderedCollection reversed() { return collection; } + @Override + public void addFirst(boolean e) { collection.addLast(e); } + @Override + public void addLast(boolean e) { collection.addFirst(e); } + @Override + public boolean contains(boolean e) { return collection.contains(e); } + @Override + public boolean remBoolean(boolean e) { return collection.remBoolean(e); } + @Override + public void clear() { collection.clear(); } + @Override + public boolean getFirstBoolean() { return collection.getLastBoolean(); } + @Override + public boolean removeFirstBoolean() { return collection.removeLastBoolean(); } + @Override + public boolean getLastBoolean() { return collection.getFirstBoolean(); } + @Override + public boolean removeLastBoolean() { return collection.removeFirstBoolean(); } + @Override + public BooleanIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements BooleanListIterator { + BooleanListIterator it; + + public ReverseBiIterator(BooleanListIterator it) { + this.it = it; + } + + @Override + public boolean nextBoolean() { return it.previousBoolean(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public boolean previousBoolean() { return it.nextBoolean(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(boolean e) { it.set(e); } + @Override + public void add(boolean e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/booleans/collections/BooleanBidirectionalIterator.java b/src/main/java/speiger/src/collections/booleans/collections/BooleanBidirectionalIterator.java index 4c919a5..71f63a8 100644 --- a/src/main/java/speiger/src/collections/booleans/collections/BooleanBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/booleans/collections/BooleanBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.booleans.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface BooleanBidirectionalIterator extends BooleanIterator, ObjectBidirectionalIterator +public interface BooleanBidirectionalIterator extends BooleanIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface BooleanBidirectionalIterator extends BooleanIterator, ObjectBid */ public boolean previousBoolean(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Boolean previous() { return Boolean.valueOf(previousBoolean()); diff --git a/src/main/java/speiger/src/collections/booleans/collections/BooleanOrderedCollection.java b/src/main/java/speiger/src/collections/booleans/collections/BooleanOrderedCollection.java new file mode 100644 index 0000000..7460818 --- /dev/null +++ b/src/main/java/speiger/src/collections/booleans/collections/BooleanOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.booleans.collections; + +public interface BooleanOrderedCollection extends BooleanCollection { + + BooleanOrderedCollection 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(boolean 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(boolean e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public boolean getFirstBoolean(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public boolean removeFirstBoolean(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public boolean getLastBoolean(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public boolean removeLastBoolean(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/booleans/lists/AbstractBooleanList.java b/src/main/java/speiger/src/collections/booleans/lists/AbstractBooleanList.java index 7d47bc4..d0a908d 100644 --- a/src/main/java/speiger/src/collections/booleans/lists/AbstractBooleanList.java +++ b/src/main/java/speiger/src/collections/booleans/lists/AbstractBooleanList.java @@ -466,7 +466,6 @@ public abstract class AbstractBooleanList extends AbstractBooleanCollection impl public int size() { return size; } - @Override public BooleanSplititerator spliterator() { return BooleanSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/booleans/lists/BooleanLinkedList.java b/src/main/java/speiger/src/collections/booleans/lists/BooleanLinkedList.java index 5826bb5..73aced2 100644 --- a/src/main/java/speiger/src/collections/booleans/lists/BooleanLinkedList.java +++ b/src/main/java/speiger/src/collections/booleans/lists/BooleanLinkedList.java @@ -356,7 +356,7 @@ public class BooleanLinkedList extends AbstractBooleanList implements BooleanPri if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator diff --git a/src/main/java/speiger/src/collections/booleans/lists/BooleanList.java b/src/main/java/speiger/src/collections/booleans/lists/BooleanList.java index d31cb4d..2880d29 100644 --- a/src/main/java/speiger/src/collections/booleans/lists/BooleanList.java +++ b/src/main/java/speiger/src/collections/booleans/lists/BooleanList.java @@ -6,6 +6,7 @@ import java.util.Objects; import java.util.Comparator; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanSplititerator; import speiger.src.collections.ints.functions.consumer.IntBooleanConsumer; import speiger.src.collections.booleans.functions.BooleanComparator; @@ -17,7 +18,7 @@ import speiger.src.collections.booleans.utils.BooleanSplititerators; /** * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features */ -public interface BooleanList extends BooleanCollection, List +public interface BooleanList extends BooleanOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -80,6 +81,24 @@ public interface BooleanList extends BooleanCollection, List */ public boolean addAll(int index, BooleanList 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(boolean 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(boolean e) { + add(e); + } + /** * 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. @@ -392,9 +411,9 @@ public interface BooleanList extends BooleanCollection, List @Override @Deprecated public default boolean add(Boolean e) { - return BooleanCollection.super.add(e); + return BooleanOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -442,7 +461,7 @@ public interface BooleanList extends BooleanCollection, List @Override @Deprecated public default boolean contains(Object o) { - return BooleanCollection.super.contains(o); + return BooleanOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -452,7 +471,7 @@ public interface BooleanList extends BooleanCollection, List @Override @Deprecated public default boolean remove(Object o) { - return BooleanCollection.super.remove(o); + return BooleanOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/booleans/utils/BooleanCollections.java b/src/main/java/speiger/src/collections/booleans/utils/BooleanCollections.java index d1189f2..01a5543 100644 --- a/src/main/java/speiger/src/collections/booleans/utils/BooleanCollections.java +++ b/src/main/java/speiger/src/collections/booleans/utils/BooleanCollections.java @@ -10,6 +10,7 @@ import java.util.function.Consumer; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -48,6 +49,34 @@ public class BooleanCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static BooleanOrderedCollection unmodifiable(BooleanOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static BooleanOrderedCollection synchronize(BooleanOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static BooleanOrderedCollection synchronize(BooleanOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -288,6 +317,37 @@ public class BooleanCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements BooleanOrderedCollection { + BooleanOrderedCollection c; + + SynchronizedOrderedCollection(BooleanOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(BooleanOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public BooleanOrderedCollection reversed() { return BooleanCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(boolean e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(boolean e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public boolean getFirstBoolean() { synchronized(mutex) { return this.c.getFirstBoolean(); } } + @Override + public boolean removeFirstBoolean() { synchronized(mutex) { return this.c.removeFirstBoolean(); } } + @Override + public boolean getLastBoolean() { synchronized(mutex) { return this.c.getLastBoolean(); } } + @Override + public boolean removeLastBoolean() { synchronized(mutex) { return this.c.removeLastBoolean(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -407,6 +467,33 @@ public class BooleanCollections public int count(BooleanPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements BooleanOrderedCollection { + BooleanOrderedCollection c; + + UnmodifiableOrderedCollection(BooleanOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public BooleanOrderedCollection reversed() { return BooleanCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return c.getFirstBoolean(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return c.getLastBoolean(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/booleans/utils/BooleanIterators.java b/src/main/java/speiger/src/collections/booleans/utils/BooleanIterators.java index c9639ad..09bff68 100644 --- a/src/main/java/speiger/src/collections/booleans/utils/BooleanIterators.java +++ b/src/main/java/speiger/src/collections/booleans/utils/BooleanIterators.java @@ -34,7 +34,7 @@ public class BooleanIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static BooleanListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class BooleanIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(boolean... a) { + public static BooleanIterator wrap(boolean... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class BooleanIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(boolean[] a, int start, int end) { + public static BooleanIterator wrap(boolean[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/booleans/utils/BooleanLists.java b/src/main/java/speiger/src/collections/booleans/utils/BooleanLists.java index c05f576..2fbb8b6 100644 --- a/src/main/java/speiger/src/collections/booleans/utils/BooleanLists.java +++ b/src/main/java/speiger/src/collections/booleans/utils/BooleanLists.java @@ -29,7 +29,7 @@ public class BooleanLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static BooleanList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/bytes/collections/AbstractByteCollection.java b/src/main/java/speiger/src/collections/bytes/collections/AbstractByteCollection.java index 81b85a5..19d34b3 100644 --- a/src/main/java/speiger/src/collections/bytes/collections/AbstractByteCollection.java +++ b/src/main/java/speiger/src/collections/bytes/collections/AbstractByteCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.bytes.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.bytes.lists.ByteListIterator; import speiger.src.collections.bytes.functions.ByteConsumer; import speiger.src.collections.bytes.utils.ByteIterators; import speiger.src.collections.bytes.utils.ByteArrays; @@ -249,4 +251,68 @@ public abstract class AbstractByteCollection extends AbstractCollection im if (a.length > size()) a[size()] = (byte)0; return a; } + + public static class ReverseByteOrderedCollection extends AbstractByteCollection implements ByteOrderedCollection { + ByteOrderedCollection collection; + Supplier reverseIterator; + + public ReverseByteOrderedCollection(ByteOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(byte o) { return collection.add(o); } + @Override + public ByteOrderedCollection reversed() { return collection; } + @Override + public void addFirst(byte e) { collection.addLast(e); } + @Override + public void addLast(byte e) { collection.addFirst(e); } + @Override + public boolean contains(byte e) { return collection.contains(e); } + @Override + public boolean remByte(byte e) { return collection.remByte(e); } + @Override + public void clear() { collection.clear(); } + @Override + public byte getFirstByte() { return collection.getLastByte(); } + @Override + public byte removeFirstByte() { return collection.removeLastByte(); } + @Override + public byte getLastByte() { return collection.getFirstByte(); } + @Override + public byte removeLastByte() { return collection.removeFirstByte(); } + @Override + public ByteIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements ByteListIterator { + ByteListIterator it; + + public ReverseBiIterator(ByteListIterator it) { + this.it = it; + } + + @Override + public byte nextByte() { return it.previousByte(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public byte previousByte() { return it.nextByte(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(byte e) { it.set(e); } + @Override + public void add(byte e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/bytes/collections/ByteBidirectionalIterator.java b/src/main/java/speiger/src/collections/bytes/collections/ByteBidirectionalIterator.java index 544573a..f778531 100644 --- a/src/main/java/speiger/src/collections/bytes/collections/ByteBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/bytes/collections/ByteBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.bytes.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface ByteBidirectionalIterator extends ByteIterator, ObjectBidirectionalIterator +public interface ByteBidirectionalIterator extends ByteIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface ByteBidirectionalIterator extends ByteIterator, ObjectBidirecti */ public byte previousByte(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Byte previous() { return Byte.valueOf(previousByte()); diff --git a/src/main/java/speiger/src/collections/bytes/collections/ByteOrderedCollection.java b/src/main/java/speiger/src/collections/bytes/collections/ByteOrderedCollection.java new file mode 100644 index 0000000..0811013 --- /dev/null +++ b/src/main/java/speiger/src/collections/bytes/collections/ByteOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.bytes.collections; + +public interface ByteOrderedCollection extends ByteCollection { + + ByteOrderedCollection 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(byte 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(byte e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public byte getFirstByte(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public byte removeFirstByte(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public byte getLastByte(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public byte removeLastByte(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/bytes/lists/AbstractByteList.java b/src/main/java/speiger/src/collections/bytes/lists/AbstractByteList.java index 360803f..95441f3 100644 --- a/src/main/java/speiger/src/collections/bytes/lists/AbstractByteList.java +++ b/src/main/java/speiger/src/collections/bytes/lists/AbstractByteList.java @@ -466,7 +466,6 @@ public abstract class AbstractByteList extends AbstractByteCollection implements public int size() { return size; } - @Override public ByteSplititerator spliterator() { return ByteSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/bytes/lists/ByteLinkedList.java b/src/main/java/speiger/src/collections/bytes/lists/ByteLinkedList.java index 958c240..25be60d 100644 --- a/src/main/java/speiger/src/collections/bytes/lists/ByteLinkedList.java +++ b/src/main/java/speiger/src/collections/bytes/lists/ByteLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.bytes.functions.ByteConsumer; import speiger.src.collections.bytes.utils.ByteArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.IntStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.bytes.collections.ByteSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.bytes.collections.ByteSplititerator; import speiger.src.collections.bytes.utils.ByteSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class ByteLinkedList extends AbstractByteList implements BytePriorityDequ if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class ByteLinkedList extends AbstractByteList implements BytePriorityDequ * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } - /** + public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/bytes/lists/ByteList.java b/src/main/java/speiger/src/collections/bytes/lists/ByteList.java index b47b05a..0210a3f 100644 --- a/src/main/java/speiger/src/collections/bytes/lists/ByteList.java +++ b/src/main/java/speiger/src/collections/bytes/lists/ByteList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteSplititerator; import speiger.src.collections.ints.functions.consumer.IntByteConsumer; import speiger.src.collections.bytes.functions.ByteComparator; @@ -21,7 +22,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 */ -public interface ByteList extends ByteCollection, List +public interface ByteList extends ByteOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -84,6 +85,24 @@ public interface ByteList extends ByteCollection, List */ public boolean addAll(int index, ByteList 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(byte 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(byte e) { + add(e); + } + /** * 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. @@ -414,9 +433,9 @@ public interface ByteList extends ByteCollection, List @Override @Deprecated public default boolean add(Byte e) { - return ByteCollection.super.add(e); + return ByteOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -464,7 +483,7 @@ public interface ByteList extends ByteCollection, List @Override @Deprecated public default boolean contains(Object o) { - return ByteCollection.super.contains(o); + return ByteOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -474,7 +493,7 @@ public interface ByteList extends ByteCollection, List @Override @Deprecated public default boolean remove(Object o) { - return ByteCollection.super.remove(o); + return ByteOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2BooleanMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2BooleanMap.java index 5d930b7..6cc3cf4 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2BooleanMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteBooleanConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.bytes.functions.function.ByteBooleanUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2BooleanMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2BooleanOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractByte2BooleanMap extends AbstractMap public void putAll(Byte[] keys, Boolean[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedByte2BooleanOrderedMap extends AbstractByte2BooleanMap implements Byte2BooleanOrderedMap { + Byte2BooleanOrderedMap map; + + public ReversedByte2BooleanOrderedMap(Byte2BooleanOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2BooleanMap setDefaultReturnValue(boolean v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public boolean getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2BooleanOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public boolean put(byte key, boolean value) { return map.put(key, value); } + @Override + public boolean putIfAbsent(byte key, boolean value) { return map.putIfAbsent(key, value); } + @Override + public boolean remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, boolean value) { return map.remove(key, value); } + @Override + public boolean removeOrDefault(byte key, boolean defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(boolean value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, boolean oldValue, boolean newValue) { return map.replace(key, oldValue, newValue); } + @Override + public boolean replace(byte key, boolean value) { return map.replace(key, value); } + @Override + public void replaceBooleans(Byte2BooleanMap m) { map.replaceBooleans(m); } + @Override + public void replaceBooleans(ByteBooleanUnaryOperator mappingFunction) { map.replaceBooleans(mappingFunction); } + @Override + public boolean computeBoolean(byte key, ByteBooleanUnaryOperator mappingFunction) { return map.computeBoolean(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsent(byte key, BytePredicate mappingFunction) { return map.computeBooleanIfAbsent(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsent(byte key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsent(key, valueProvider); } + @Override + public boolean computeBooleanIfPresent(byte key, ByteBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresent(key, mappingFunction); } + @Override + public boolean computeBooleanNonDefault(byte key, ByteBooleanUnaryOperator mappingFunction) { return map.computeBooleanNonDefault(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsentNonDefault(byte key, BytePredicate mappingFunction) { return map.computeBooleanIfAbsentNonDefault(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsentNonDefault(byte key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsentNonDefault(key, valueProvider); } + @Override + public boolean computeBooleanIfPresentNonDefault(byte key, ByteBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresentNonDefault(key, mappingFunction); } + @Override + public boolean mergeBoolean(byte key, boolean value, BooleanBooleanUnaryOperator mappingFunction) { return map.mergeBoolean(key, value, mappingFunction); } + @Override + public boolean getOrDefault(byte key, boolean defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public boolean get(byte key) { return map.get(key); } + @Override + public boolean putAndMoveToFirst(byte key, boolean value) { return map.putAndMoveToLast(key, value); } + @Override + public boolean putAndMoveToLast(byte key, boolean value) { return map.putAndMoveToFirst(key, value); } + @Override + public boolean putFirst(byte key, boolean value) { return map.putLast(key, value); } + @Override + public boolean putLast(byte key, boolean value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public boolean getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public boolean getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public boolean firstBooleanValue() { return map.lastBooleanValue(); } + @Override + public boolean lastBooleanValue() { return map.firstBooleanValue(); } + @Override + public Byte2BooleanMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2BooleanMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2BooleanMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2BooleanEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ByteMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ByteMap.java index 62847fc..c5298a2 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ByteMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteByteConsumer; import speiger.src.collections.bytes.functions.function.ByteUnaryOperator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2ByteMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2ByteOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2ByteMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2ByteMap extends AbstractMap implements Byte2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractByte2ByteMap extends AbstractMap imple public void putAll(Byte[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imple return hash; } + public static class ReversedByte2ByteOrderedMap extends AbstractByte2ByteMap implements Byte2ByteOrderedMap { + Byte2ByteOrderedMap map; + + public ReversedByte2ByteOrderedMap(Byte2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(byte key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(byte key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(byte key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(byte key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(byte key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(byte key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Byte2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(ByteByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(byte key, ByteByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(byte key, ByteUnaryOperator mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(byte key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(byte key, ByteByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(byte key, ByteByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(byte key, ByteUnaryOperator mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(byte key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(byte key, ByteByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(byte key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(byte key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(byte key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(byte key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(byte key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(byte key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(byte key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Byte2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2ByteEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2CharMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2CharMap.java index 97f5398..6236f4b 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2CharMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteCharConsumer; import speiger.src.collections.bytes.functions.function.Byte2CharFunction; import speiger.src.collections.bytes.functions.function.ByteCharUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2CharMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2CharOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2CharMap extends AbstractMap implements Byte2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2CharMap extends AbstractMap public void putAll(Byte[] keys, Character[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedByte2CharOrderedMap extends AbstractByte2CharMap implements Byte2CharOrderedMap { + Byte2CharOrderedMap map; + + public ReversedByte2CharOrderedMap(Byte2CharOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2CharMap setDefaultReturnValue(char v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public char getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2CharOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public char put(byte key, char value) { return map.put(key, value); } + @Override + public char putIfAbsent(byte key, char value) { return map.putIfAbsent(key, value); } + @Override + public char addTo(byte key, char value) { return map.addTo(key, value); } + @Override + public char subFrom(byte key, char value) { return map.subFrom(key, value); } + @Override + public char remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, char value) { return map.remove(key, value); } + @Override + public char removeOrDefault(byte key, char defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(char value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, char oldValue, char newValue) { return map.replace(key, oldValue, newValue); } + @Override + public char replace(byte key, char value) { return map.replace(key, value); } + @Override + public void replaceChars(Byte2CharMap m) { map.replaceChars(m); } + @Override + public void replaceChars(ByteCharUnaryOperator mappingFunction) { map.replaceChars(mappingFunction); } + @Override + public char computeChar(byte key, ByteCharUnaryOperator mappingFunction) { return map.computeChar(key, mappingFunction); } + @Override + public char computeCharIfAbsent(byte key, Byte2CharFunction mappingFunction) { return map.computeCharIfAbsent(key, mappingFunction); } + @Override + public char supplyCharIfAbsent(byte key, CharSupplier valueProvider) { return map.supplyCharIfAbsent(key, valueProvider); } + @Override + public char computeCharIfPresent(byte key, ByteCharUnaryOperator mappingFunction) { return map.computeCharIfPresent(key, mappingFunction); } + @Override + public char computeCharNonDefault(byte key, ByteCharUnaryOperator mappingFunction) { return map.computeCharNonDefault(key, mappingFunction); } + @Override + public char computeCharIfAbsentNonDefault(byte key, Byte2CharFunction mappingFunction) { return map.computeCharIfAbsentNonDefault(key, mappingFunction); } + @Override + public char supplyCharIfAbsentNonDefault(byte key, CharSupplier valueProvider) { return map.supplyCharIfAbsentNonDefault(key, valueProvider); } + @Override + public char computeCharIfPresentNonDefault(byte key, ByteCharUnaryOperator mappingFunction) { return map.computeCharIfPresentNonDefault(key, mappingFunction); } + @Override + public char mergeChar(byte key, char value, CharCharUnaryOperator mappingFunction) { return map.mergeChar(key, value, mappingFunction); } + @Override + public char getOrDefault(byte key, char defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public char get(byte key) { return map.get(key); } + @Override + public char putAndMoveToFirst(byte key, char value) { return map.putAndMoveToLast(key, value); } + @Override + public char putAndMoveToLast(byte key, char value) { return map.putAndMoveToFirst(key, value); } + @Override + public char putFirst(byte key, char value) { return map.putLast(key, value); } + @Override + public char putLast(byte key, char value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public char getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public char getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public char firstCharValue() { return map.lastCharValue(); } + @Override + public char lastCharValue() { return map.firstCharValue(); } + @Override + public Byte2CharMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2CharMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2CharMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2CharMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2CharEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2DoubleMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2DoubleMap.java index 0e3db33..9d5c404 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2DoubleMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteDoubleConsumer; import speiger.src.collections.bytes.functions.function.Byte2DoubleFunction; import speiger.src.collections.bytes.functions.function.ByteDoubleUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2DoubleMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2DoubleOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2DoubleMap extends AbstractMap implements Byte2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2DoubleMap extends AbstractMap i public void putAll(Byte[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedByte2DoubleOrderedMap extends AbstractByte2DoubleMap implements Byte2DoubleOrderedMap { + Byte2DoubleOrderedMap map; + + public ReversedByte2DoubleOrderedMap(Byte2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(byte key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(byte key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(byte key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(byte key, double value) { return map.subFrom(key, value); } + @Override + public double remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, double value) { return map.remove(key, value); } + @Override + public double removeOrDefault(byte key, double defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(byte key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Byte2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(ByteDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(byte key, ByteDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(byte key, Byte2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(byte key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(byte key, ByteDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(byte key, ByteDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(byte key, Byte2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(byte key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(byte key, ByteDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(byte key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(byte key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double get(byte key) { return map.get(key); } + @Override + public double putAndMoveToFirst(byte key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(byte key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(byte key, double value) { return map.putLast(key, value); } + @Override + public double putLast(byte key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Byte2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2DoubleEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2FloatMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2FloatMap.java index 9d8c6bb..5e807a6 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2FloatMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteFloatConsumer; import speiger.src.collections.bytes.functions.function.Byte2FloatFunction; import speiger.src.collections.bytes.functions.function.ByteFloatUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2FloatMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2FloatOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2FloatMap extends AbstractMap implements Byte2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2FloatMap extends AbstractMap imp public void putAll(Byte[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedByte2FloatOrderedMap extends AbstractByte2FloatMap implements Byte2FloatOrderedMap { + Byte2FloatOrderedMap map; + + public ReversedByte2FloatOrderedMap(Byte2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(byte key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(byte key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(byte key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(byte key, float value) { return map.subFrom(key, value); } + @Override + public float remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(byte key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(byte key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Byte2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(ByteFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(byte key, ByteFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(byte key, Byte2FloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(byte key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(byte key, ByteFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(byte key, ByteFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(byte key, Byte2FloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(byte key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(byte key, ByteFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(byte key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(byte key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(byte key) { return map.get(key); } + @Override + public float putAndMoveToFirst(byte key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(byte key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(byte key, float value) { return map.putLast(key, value); } + @Override + public float putLast(byte key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Byte2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2FloatEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2IntMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2IntMap.java index f2b7195..86a07b7 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2IntMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteIntConsumer; import speiger.src.collections.bytes.functions.function.Byte2IntFunction; import speiger.src.collections.bytes.functions.function.ByteIntUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2IntMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2IntOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2IntMap extends AbstractMap implements Byte2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2IntMap extends AbstractMap imp public void putAll(Byte[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedByte2IntOrderedMap extends AbstractByte2IntMap implements Byte2IntOrderedMap { + Byte2IntOrderedMap map; + + public ReversedByte2IntOrderedMap(Byte2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(byte key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(byte key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(byte key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(byte key, int value) { return map.subFrom(key, value); } + @Override + public int remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(byte key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(byte key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Byte2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(ByteIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(byte key, ByteIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(byte key, Byte2IntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(byte key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(byte key, ByteIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(byte key, ByteIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(byte key, Byte2IntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(byte key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(byte key, ByteIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(byte key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(byte key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(byte key) { return map.get(key); } + @Override + public int putAndMoveToFirst(byte key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(byte key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(byte key, int value) { return map.putLast(key, value); } + @Override + public int putLast(byte key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Byte2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2IntEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2LongMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2LongMap.java index 8d55117..b2a55b5 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2LongMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteLongConsumer; import speiger.src.collections.bytes.functions.function.Byte2LongFunction; import speiger.src.collections.bytes.functions.function.ByteLongUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2LongMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2LongOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2LongMap extends AbstractMap implements Byte2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2LongMap extends AbstractMap imple public void putAll(Byte[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imple return hash; } + public static class ReversedByte2LongOrderedMap extends AbstractByte2LongMap implements Byte2LongOrderedMap { + Byte2LongOrderedMap map; + + public ReversedByte2LongOrderedMap(Byte2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(byte key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(byte key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(byte key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(byte key, long value) { return map.subFrom(key, value); } + @Override + public long remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(byte key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(byte key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Byte2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(ByteLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(byte key, ByteLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(byte key, Byte2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(byte key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(byte key, ByteLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(byte key, ByteLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(byte key, Byte2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(byte key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(byte key, ByteLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(byte key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(byte key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(byte key) { return map.get(key); } + @Override + public long putAndMoveToFirst(byte key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(byte key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(byte key, long value) { return map.putLast(key, value); } + @Override + public long putLast(byte key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Byte2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2LongEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ObjectMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ObjectMap.java index e258494..0deb0b8 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ObjectMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteObjectConsumer; import speiger.src.collections.bytes.functions.function.ByteFunction; import speiger.src.collections.bytes.functions.function.ByteObjectUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2ObjectMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2ObjectOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractByte2ObjectMap extends AbstractMap imp public void putAll(Byte[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap imp return hash; } + public static class ReversedByte2ObjectOrderedMap extends AbstractByte2ObjectMap implements Byte2ObjectOrderedMap { + Byte2ObjectOrderedMap map; + + public ReversedByte2ObjectOrderedMap(Byte2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(byte key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(byte key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(byte key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(byte key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Byte2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(ByteObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(byte key, ByteObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(byte key, ByteFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(byte key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(byte key, ByteObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(byte key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(byte key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(byte key) { return map.get(key); } + @Override + public V putAndMoveToFirst(byte key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(byte key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(byte key, V value) { return map.putLast(key, value); } + @Override + public V putLast(byte key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Byte2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> byte2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2ObjectEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ShortMap.java b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ShortMap.java index 3922aa3..5dad4dc 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ShortMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/abstracts/AbstractByte2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.bytes.functions.consumer.ByteShortConsumer; import speiger.src.collections.bytes.functions.function.Byte2ShortFunction; import speiger.src.collections.bytes.functions.function.ByteShortUnaryOperator; import speiger.src.collections.bytes.maps.interfaces.Byte2ShortMap; +import speiger.src.collections.bytes.maps.interfaces.Byte2ShortOrderedMap; +import speiger.src.collections.bytes.sets.ByteOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.maps.Byte2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractByte2ShortMap extends AbstractMap implements Byte2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractByte2ShortMap extends AbstractMap imp public void putAll(Byte[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedByte2ShortOrderedMap extends AbstractByte2ShortMap implements Byte2ShortOrderedMap { + Byte2ShortOrderedMap map; + + public ReversedByte2ShortOrderedMap(Byte2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractByte2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Byte2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(byte key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(byte key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(byte key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(byte key, short value) { return map.subFrom(key, value); } + @Override + public short remove(byte key) { return map.remove(key); } + @Override + public boolean remove(byte key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(byte key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(byte key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(byte key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(byte key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Byte2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(ByteShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(byte key, ByteShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(byte key, Byte2ShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(byte key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(byte key, ByteShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(byte key, ByteShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(byte key, Byte2ShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(byte key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(byte key, ByteShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(byte key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(byte key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(byte key) { return map.get(key); } + @Override + public short putAndMoveToFirst(byte key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(byte key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(byte key, short value) { return map.putLast(key, value); } + @Override + public short putLast(byte key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(byte key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(byte key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(byte key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(byte key) { return map.getAndMoveToFirst(key); } + @Override + public byte firstByteKey() { return map.lastByteKey(); } + @Override + public byte pollFirstByteKey() { return map.pollLastByteKey(); } + @Override + public byte lastByteKey() { return map.firstByteKey(); } + @Override + public byte pollLastByteKey() { return map.pollFirstByteKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Byte2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Byte2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Byte2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Byte2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet byte2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.byte2ShortEntrySet()); } + @Override + public ByteOrderedSet keySet() { return new AbstractByteSet.ReversedByteOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Byte2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2BooleanLinkedOpenCustomHashMap.java index eb98cc8..56c18f2 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH return getDefaultReturnValue(); } + @Override + public boolean putFirst(byte key, boolean value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 boolean putLast(byte key, boolean value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH return values[lastIndex]; } + @Override + public Byte2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } @Override - public Byte2BooleanMap.Entry first() { + public Byte2BooleanMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstBooleanValue()); } @Override - public Byte2BooleanMap.Entry last() { + public Byte2BooleanMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastBooleanValue()); } @Override - public Byte2BooleanMap.Entry pollFirst() { + public Byte2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstBooleanValue()); pollFirstByteKey(); return entry; } @Override - public Byte2BooleanMap.Entry pollLast() { + public Byte2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastBooleanValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstByteKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Byte2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2BooleanLinkedOpenCustomHashMap extends Byte2BooleanOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ByteLinkedOpenCustomHashMap.java index e6e1680..54d2a1b 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ByteLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public byte putFirst(byte key, byte value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 byte putLast(byte key, byte value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -386,6 +434,52 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap return values[lastIndex]; } + @Override + public Byte2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } @Override - public Byte2ByteMap.Entry first() { + public Byte2ByteMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstByteValue()); } @Override - public Byte2ByteMap.Entry last() { + public Byte2ByteMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastByteValue()); } @Override - public Byte2ByteMap.Entry pollFirst() { + public Byte2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstByteValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ByteMap.Entry pollLast() { + public Byte2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastByteValue()); pollLastByteKey(); return entry; @@ -611,7 +705,12 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1023,30 +1127,41 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstByteKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Byte2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastByteKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1204,7 +1319,7 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1234,7 +1349,7 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1256,7 +1371,7 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1277,16 +1392,20 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Byte2ByteLinkedOpenCustomHashMap extends Byte2ByteOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2CharLinkedOpenCustomHashMap.java index 57c5a35..8af011a 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2CharLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -258,6 +258,54 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public char putFirst(byte key, char value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 char putLast(byte key, char value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap return values[lastIndex]; } + @Override + public Byte2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } @Override - public Byte2CharMap.Entry first() { + public Byte2CharMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstCharValue()); } @Override - public Byte2CharMap.Entry last() { + public Byte2CharMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastCharValue()); } @Override - public Byte2CharMap.Entry pollFirst() { + public Byte2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstCharValue()); pollFirstByteKey(); return entry; } @Override - public Byte2CharMap.Entry pollLast() { + public Byte2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastCharValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstByteKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Byte2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1284,16 +1399,20 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2CharLinkedOpenCustomHashMap extends Byte2CharOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2DoubleLinkedOpenCustomHashMap.java index f77f1c5..9eb2bbb 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2DoubleLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -258,6 +258,54 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas return getDefaultReturnValue(); } + @Override + public double putFirst(byte key, double value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 double putLast(byte key, double value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas return values[lastIndex]; } + @Override + public Byte2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } @Override - public Byte2DoubleMap.Entry first() { + public Byte2DoubleMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstDoubleValue()); } @Override - public Byte2DoubleMap.Entry last() { + public Byte2DoubleMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastDoubleValue()); } @Override - public Byte2DoubleMap.Entry pollFirst() { + public Byte2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstDoubleValue()); pollFirstByteKey(); return entry; } @Override - public Byte2DoubleMap.Entry pollLast() { + public Byte2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastDoubleValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstByteKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Byte2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1284,16 +1399,20 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2DoubleLinkedOpenCustomHashMap extends Byte2DoubleOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2FloatLinkedOpenCustomHashMap.java index 1d183ad..d248aee 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2FloatLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -258,6 +258,54 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM return getDefaultReturnValue(); } + @Override + public float putFirst(byte key, float value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 float putLast(byte key, float value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM return values[lastIndex]; } + @Override + public Byte2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } @Override - public Byte2FloatMap.Entry first() { + public Byte2FloatMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstFloatValue()); } @Override - public Byte2FloatMap.Entry last() { + public Byte2FloatMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastFloatValue()); } @Override - public Byte2FloatMap.Entry pollFirst() { + public Byte2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstFloatValue()); pollFirstByteKey(); return entry; } @Override - public Byte2FloatMap.Entry pollLast() { + public Byte2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastFloatValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstByteKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Byte2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1284,16 +1399,20 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2FloatLinkedOpenCustomHashMap extends Byte2FloatOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2IntLinkedOpenCustomHashMap.java index 3f0a50d..2ca960a 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public int putFirst(byte key, int value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 int putLast(byte key, int value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i return values[lastIndex]; } + @Override + public Byte2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } @Override - public Byte2IntMap.Entry first() { + public Byte2IntMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstIntValue()); } @Override - public Byte2IntMap.Entry last() { + public Byte2IntMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastIntValue()); } @Override - public Byte2IntMap.Entry pollFirst() { + public Byte2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstIntValue()); pollFirstByteKey(); return entry; } @Override - public Byte2IntMap.Entry pollLast() { + public Byte2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastIntValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstByteKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Byte2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2IntLinkedOpenCustomHashMap extends Byte2IntOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2LongLinkedOpenCustomHashMap.java index c2a45e7..a05766e 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2LongLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -258,6 +258,54 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public long putFirst(byte key, long value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 long putLast(byte key, long value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap return values[lastIndex]; } + @Override + public Byte2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } @Override - public Byte2LongMap.Entry first() { + public Byte2LongMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstLongValue()); } @Override - public Byte2LongMap.Entry last() { + public Byte2LongMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastLongValue()); } @Override - public Byte2LongMap.Entry pollFirst() { + public Byte2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstLongValue()); pollFirstByteKey(); return entry; } @Override - public Byte2LongMap.Entry pollLast() { + public Byte2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastLongValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstByteKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Byte2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1284,16 +1399,20 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2LongLinkedOpenCustomHashMap extends Byte2LongOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ObjectLinkedOpenCustomHashMap.java index 25f2f5f..cbd1321 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom return getDefaultReturnValue(); } + @Override + public V putFirst(byte key, V value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 V putLast(byte key, V value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -388,6 +436,52 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom return values[lastIndex]; } + @Override + public Byte2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> byte2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } @Override - public Byte2ObjectMap.Entry first() { + public Byte2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstByteKey(), firstValue()); } @Override - public Byte2ObjectMap.Entry last() { + public Byte2ObjectMap.Entry getLast() { return new BasicEntry<>(lastByteKey(), lastValue()); } @Override - public Byte2ObjectMap.Entry pollFirst() { + public Byte2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstByteKey(), firstValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ObjectMap.Entry pollLast() { + public Byte2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastByteKey(), lastValue()); pollLastByteKey(); return entry; @@ -613,7 +707,12 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,31 +1129,42 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Byte2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Byte2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Byte2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstByteKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastByteKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Byte2ObjectLinkedOpenCustomHashMap extends Byte2ObjectOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ShortLinkedOpenCustomHashMap.java index b39e058..f781472 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/customHash/Byte2ShortLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.utils.ByteStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -258,6 +258,54 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM return getDefaultReturnValue(); } + @Override + public short putFirst(byte key, short value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + 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 short putLast(byte key, short value) { + if(strategy.equals(key, (byte)0)) { + 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], (byte)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || strategy.equals(firstByteKey(), key)) return false; @@ -393,6 +441,52 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM return values[lastIndex]; } + @Override + public Byte2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getByteKey(), (byte)0)) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } @Override - public Byte2ShortMap.Entry first() { + public Byte2ShortMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstShortValue()); } @Override - public Byte2ShortMap.Entry last() { + public Byte2ShortMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastShortValue()); } @Override - public Byte2ShortMap.Entry pollFirst() { + public Byte2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstShortValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ShortMap.Entry pollLast() { + public Byte2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastShortValue()); pollLastByteKey(); return entry; @@ -618,7 +712,12 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1030,30 +1134,41 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Byte2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Byte2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstByteKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Byte2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Byte2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastByteKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1211,7 +1326,7 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1241,7 +1356,7 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1263,7 +1378,7 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1284,16 +1399,20 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Byte2ShortLinkedOpenCustomHashMap extends Byte2ShortOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2BooleanLinkedOpenHashMap.java index 2a31ccd..bf550d1 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2BooleanOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple return getDefaultReturnValue(); } + @Override + public boolean putFirst(byte key, boolean value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 boolean putLast(byte key, boolean value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple return values[lastIndex]; } + @Override + public Byte2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } @Override - public Byte2BooleanMap.Entry first() { + public Byte2BooleanMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstBooleanValue()); } @Override - public Byte2BooleanMap.Entry last() { + public Byte2BooleanMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastBooleanValue()); } @Override - public Byte2BooleanMap.Entry pollFirst() { + public Byte2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstBooleanValue()); pollFirstByteKey(); return entry; } @Override - public Byte2BooleanMap.Entry pollLast() { + public Byte2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastBooleanValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Byte2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstByteKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2BooleanLinkedOpenHashMap extends Byte2BooleanOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ByteLinkedOpenHashMap.java index b6cd8da..d4403b2 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ByteLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ByteOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements return getDefaultReturnValue(); } + @Override + public byte putFirst(byte key, byte value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 byte putLast(byte key, byte value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -384,6 +432,52 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements return values[lastIndex]; } + @Override + public Byte2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } @Override - public Byte2ByteMap.Entry first() { + public Byte2ByteMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstByteValue()); } @Override - public Byte2ByteMap.Entry last() { + public Byte2ByteMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastByteValue()); } @Override - public Byte2ByteMap.Entry pollFirst() { + public Byte2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstByteValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ByteMap.Entry pollLast() { + public Byte2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastByteValue()); pollLastByteKey(); return entry; @@ -609,7 +703,12 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1018,32 +1122,43 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Byte2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstByteKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1200,7 +1315,7 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1230,7 +1345,7 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1252,7 +1367,7 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1272,13 +1387,16 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1309,11 +1427,11 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Byte2ByteLinkedOpenHashMap extends Byte2ByteOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2CharLinkedOpenHashMap.java index 409d087..be5580d 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2CharLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2CharOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -235,6 +235,54 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements return getDefaultReturnValue(); } + @Override + public char putFirst(byte key, char value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 char putLast(byte key, char value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements return values[lastIndex]; } + @Override + public Byte2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } @Override - public Byte2CharMap.Entry first() { + public Byte2CharMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstCharValue()); } @Override - public Byte2CharMap.Entry last() { + public Byte2CharMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastCharValue()); } @Override - public Byte2CharMap.Entry pollFirst() { + public Byte2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstCharValue()); pollFirstByteKey(); return entry; } @Override - public Byte2CharMap.Entry pollLast() { + public Byte2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastCharValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2CharLinkedOpenHashMap.this.clear(); + public void clear() { Byte2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstByteKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1279,13 +1394,16 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2CharLinkedOpenHashMap extends Byte2CharOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2DoubleLinkedOpenHashMap.java index dadc145..bb568d1 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2DoubleLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2DoubleOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -235,6 +235,54 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public double putFirst(byte key, double value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 double putLast(byte key, double value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme return values[lastIndex]; } + @Override + public Byte2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } @Override - public Byte2DoubleMap.Entry first() { + public Byte2DoubleMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstDoubleValue()); } @Override - public Byte2DoubleMap.Entry last() { + public Byte2DoubleMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastDoubleValue()); } @Override - public Byte2DoubleMap.Entry pollFirst() { + public Byte2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstDoubleValue()); pollFirstByteKey(); return entry; } @Override - public Byte2DoubleMap.Entry pollLast() { + public Byte2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastDoubleValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Byte2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstByteKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1279,13 +1394,16 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2DoubleLinkedOpenHashMap extends Byte2DoubleOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2FloatLinkedOpenHashMap.java index 1a3226e..5b05dd3 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2FloatLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2FloatOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -235,6 +235,54 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement return getDefaultReturnValue(); } + @Override + public float putFirst(byte key, float value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 float putLast(byte key, float value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement return values[lastIndex]; } + @Override + public Byte2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } @Override - public Byte2FloatMap.Entry first() { + public Byte2FloatMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstFloatValue()); } @Override - public Byte2FloatMap.Entry last() { + public Byte2FloatMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastFloatValue()); } @Override - public Byte2FloatMap.Entry pollFirst() { + public Byte2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstFloatValue()); pollFirstByteKey(); return entry; } @Override - public Byte2FloatMap.Entry pollLast() { + public Byte2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastFloatValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Byte2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstByteKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1279,13 +1394,16 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2FloatLinkedOpenHashMap extends Byte2FloatOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2IntLinkedOpenHashMap.java index 39b6ca2..ff11287 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2IntOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By return getDefaultReturnValue(); } + @Override + public int putFirst(byte key, int value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 int putLast(byte key, int value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By return values[lastIndex]; } + @Override + public Byte2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } @Override - public Byte2IntMap.Entry first() { + public Byte2IntMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstIntValue()); } @Override - public Byte2IntMap.Entry last() { + public Byte2IntMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastIntValue()); } @Override - public Byte2IntMap.Entry pollFirst() { + public Byte2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstIntValue()); pollFirstByteKey(); return entry; } @Override - public Byte2IntMap.Entry pollLast() { + public Byte2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastIntValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2IntLinkedOpenHashMap.this.clear(); + public void clear() { Byte2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstByteKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2IntLinkedOpenHashMap extends Byte2IntOpenHashMap implements By public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2LongLinkedOpenHashMap.java index 159629d..b476e6c 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2LongLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2LongOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -235,6 +235,54 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements return getDefaultReturnValue(); } + @Override + public long putFirst(byte key, long value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 long putLast(byte key, long value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements return values[lastIndex]; } + @Override + public Byte2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } @Override - public Byte2LongMap.Entry first() { + public Byte2LongMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstLongValue()); } @Override - public Byte2LongMap.Entry last() { + public Byte2LongMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastLongValue()); } @Override - public Byte2LongMap.Entry pollFirst() { + public Byte2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstLongValue()); pollFirstByteKey(); return entry; } @Override - public Byte2LongMap.Entry pollLast() { + public Byte2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastLongValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2LongLinkedOpenHashMap.this.clear(); + public void clear() { Byte2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstByteKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1279,13 +1394,16 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2LongLinkedOpenHashMap extends Byte2LongOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ObjectLinkedOpenHashMap.java index 23f0f0f..d304acb 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ObjectOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i return getDefaultReturnValue(); } + @Override + public V putFirst(byte key, V value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 V putLast(byte key, V value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -375,6 +423,52 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i return values[lastIndex]; } + @Override + public Byte2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> byte2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } @Override - public Byte2ObjectMap.Entry first() { + public Byte2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstByteKey(), firstValue()); } @Override - public Byte2ObjectMap.Entry last() { + public Byte2ObjectMap.Entry getLast() { return new BasicEntry<>(lastByteKey(), lastValue()); } @Override - public Byte2ObjectMap.Entry pollFirst() { + public Byte2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstByteKey(), firstValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ObjectMap.Entry pollLast() { + public Byte2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastByteKey(), lastValue()); pollLastByteKey(); return entry; @@ -600,7 +694,12 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1009,33 +1113,44 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Byte2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstByteKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1192,7 +1307,7 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1222,7 +1337,7 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1244,7 +1359,7 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1301,11 +1419,11 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Byte2ObjectLinkedOpenHashMap extends Byte2ObjectOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ShortLinkedOpenHashMap.java index 0ba6b5e..9fcfd5c 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/hash/Byte2ShortLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ShortOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -235,6 +235,54 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement return getDefaultReturnValue(); } + @Override + public short putFirst(byte key, short value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(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 short putLast(byte key, short value) { + if(key == (byte)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Byte.hashCode(key)) & mask; + while(key == (byte)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(byte key) { if(isEmpty() || firstByteKey() == key) return false; @@ -391,6 +439,52 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement return values[lastIndex]; } + @Override + public Byte2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Byte2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getByteKey() == (byte)0) { + containsNull = false; + keys[nullIndex] = (byte)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet byte2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } @Override - public Byte2ShortMap.Entry first() { + public Byte2ShortMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstShortValue()); } @Override - public Byte2ShortMap.Entry last() { + public Byte2ShortMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastShortValue()); } @Override - public Byte2ShortMap.Entry pollFirst() { + public Byte2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstShortValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ShortMap.Entry pollLast() { + public Byte2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastShortValue()); pollLastByteKey(); return entry; @@ -616,7 +710,12 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { + public byte removeLastByte() { return pollLastByteKey(); } @@ -1025,32 +1129,43 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Byte2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Byte2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Byte2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstByteKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1207,7 +1322,7 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1237,7 +1352,7 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1259,7 +1374,7 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1279,13 +1394,16 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1316,11 +1434,11 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Byte2ShortLinkedOpenHashMap extends Byte2ShortOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2BooleanOpenHashMap.java index 65c0ff9..e2ee3f3 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im @Override public boolean putAndMoveToLast(byte key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(byte key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(byte key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im public boolean moveToLast(Byte2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2BooleanMap.Entry first() { + public Byte2BooleanMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstBooleanValue()); } @Override - public Byte2BooleanMap.Entry last() { + public Byte2BooleanMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastBooleanValue()); } @Override - public Byte2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1211,11 +1250,11 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableByte2BooleanOpenHashMap extends AbstractByte2BooleanMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ByteOpenHashMap.java index efe0c01..abbacbe 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ByteOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.bytes.utils.ByteArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen @Override public byte putAndMoveToLast(byte key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(byte key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(byte key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2ByteEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen public boolean moveToLast(Byte2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2ByteMap.Entry first() { + public Byte2ByteMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstByteValue()); } @Override - public Byte2ByteMap.Entry last() { + public Byte2ByteMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastByteValue()); } @Override - public Byte2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1170,13 +1206,16 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1207,11 +1246,11 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableByte2ByteOpenHashMap extends AbstractByte2ByteMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2CharOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2CharOpenHashMap.java index 779b272..e6dc98c 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2CharOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen @Override public char putAndMoveToLast(byte key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(byte key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(byte key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2CharEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen public boolean moveToLast(Byte2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2CharMap.Entry first() { + public Byte2CharMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstCharValue()); } @Override - public Byte2CharMap.Entry last() { + public Byte2CharMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastCharValue()); } @Override - public Byte2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2CharOpenHashMap extends AbstractByte2CharMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2DoubleOpenHashMap.java index cdf07d9..492af63 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2DoubleOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl @Override public double putAndMoveToLast(byte key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(byte key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(byte key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2DoubleEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl public boolean moveToLast(Byte2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2DoubleMap.Entry first() { + public Byte2DoubleMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstDoubleValue()); } @Override - public Byte2DoubleMap.Entry last() { + public Byte2DoubleMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastDoubleValue()); } @Override - public Byte2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2DoubleOpenHashMap extends AbstractByte2DoubleMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2FloatOpenHashMap.java index af6bb16..29ea36d 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2FloatOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem @Override public float putAndMoveToLast(byte key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(byte key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(byte key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2FloatEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem public boolean moveToLast(Byte2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2FloatMap.Entry first() { + public Byte2FloatMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstFloatValue()); } @Override - public Byte2FloatMap.Entry last() { + public Byte2FloatMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastFloatValue()); } @Override - public Byte2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2FloatOpenHashMap extends AbstractByte2FloatMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2IntOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2IntOpenHashMap.java index 91d46ec..3481ede 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements @Override public int putAndMoveToLast(byte key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(byte key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(byte key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements public boolean moveToLast(Byte2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2IntMap.Entry first() { + public Byte2IntMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstIntValue()); } @Override - public Byte2IntMap.Entry last() { + public Byte2IntMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastIntValue()); } @Override - public Byte2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2IntOpenHashMap extends AbstractByte2IntMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2LongOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2LongOpenHashMap.java index d7385a9..18bf351 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2LongOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen @Override public long putAndMoveToLast(byte key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(byte key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(byte key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2LongEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen public boolean moveToLast(Byte2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2LongMap.Entry first() { + public Byte2LongMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstLongValue()); } @Override - public Byte2LongMap.Entry last() { + public Byte2LongMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastLongValue()); } @Override - public Byte2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2LongOpenHashMap extends AbstractByte2LongMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ObjectOpenHashMap.java index 8a655dd..9e0fd8a 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> byte2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap o) { throw new UnsupportedOperationException(); } @Override - public Byte2ObjectMap.Entry first() { + public Byte2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstByteKey(), firstValue()); } @Override - public Byte2ObjectMap.Entry last() { + public Byte2ObjectMap.Entry getLast() { return new BasicEntry<>(lastByteKey(), lastValue()); } @Override - public Byte2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableByte2ObjectOpenHashMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap extends AbstractByte2ObjectMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ShortOpenHashMap.java index b79011b..0953ba8 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/immutable/ImmutableByte2ShortOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem /** KeySet cache */ protected transient ByteOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem @Override public short putAndMoveToLast(byte key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(byte key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(byte key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Byte2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Byte2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Byte2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet byte2ShortEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem public boolean moveToLast(Byte2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Byte2ShortMap.Entry first() { + public Byte2ShortMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstShortValue()); } @Override - public Byte2ShortMap.Entry last() { + public Byte2ShortMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastShortValue()); } @Override - public Byte2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem @Override public ByteListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public byte firstByte() { + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableByte2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableByte2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(byte from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(byte from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(byte from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1179,13 +1215,16 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(byte from) { @@ -1216,11 +1255,11 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableByte2ShortOpenHashMap extends AbstractByte2ShortMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2BooleanArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2BooleanArrayMap.java index 3e4e630..5ddfb05 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2BooleanOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt return lastValue; } + @Override + public boolean putFirst(byte key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(byte key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt return result; } + @Override + public Byte2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(byte key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } @Override - public Byte2BooleanMap.Entry first() { + public Byte2BooleanMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstBooleanValue()); } @Override - public Byte2BooleanMap.Entry last() { + public Byte2BooleanMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastBooleanValue()); } @Override - public Byte2BooleanMap.Entry pollFirst() { + public Byte2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstBooleanValue()); pollFirstByteKey(); return entry; } @Override - public Byte2BooleanMap.Entry pollLast() { + public Byte2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastBooleanValue()); pollLastByteKey(); return entry; @@ -720,7 +769,12 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt @Override public boolean moveToLast(byte o) { return Byte2BooleanArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt @Override public void clear() { Byte2BooleanArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2BooleanArrayMap.this.size(); - } - + public int size() { return Byte2BooleanArrayMap.this.size(); } @Override - public void clear() { - Byte2BooleanArrayMap.this.clear(); + public void clear() { Byte2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstByteKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1233,6 +1292,9 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Byte2BooleanArrayMap extends AbstractByte2BooleanMap implements Byt public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ByteArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ByteArrayMap.java index de0e62f..51f020d 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ByteArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ByteOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte return lastValue; } + @Override + public byte putFirst(byte key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(byte key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte return result; } + @Override + public Byte2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(byte key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } @Override - public Byte2ByteMap.Entry first() { + public Byte2ByteMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstByteValue()); } @Override - public Byte2ByteMap.Entry last() { + public Byte2ByteMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastByteValue()); } @Override - public Byte2ByteMap.Entry pollFirst() { + public Byte2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstByteValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ByteMap.Entry pollLast() { + public Byte2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastByteValue()); pollLastByteKey(); return entry; @@ -736,7 +785,12 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte @Override public boolean moveToLast(byte o) { return Byte2ByteArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte @Override public void clear() { Byte2ByteArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ByteArrayMap.this.size(); - } - + public int size() { return Byte2ByteArrayMap.this.size(); } @Override - public void clear() { - Byte2ByteArrayMap.this.clear(); + public void clear() { Byte2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstByteKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2ByteMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2ByteMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1249,6 +1308,9 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Byte2ByteArrayMap extends AbstractByte2ByteMap implements Byte2Byte public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2CharArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2CharArrayMap.java index bfecf90..4ad5851 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2CharArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2CharOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char return lastValue; } + @Override + public char putFirst(byte key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(byte key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char return result; } + @Override + public Byte2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } @Override - public Byte2CharMap.Entry first() { + public Byte2CharMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstCharValue()); } @Override - public Byte2CharMap.Entry last() { + public Byte2CharMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastCharValue()); } @Override - public Byte2CharMap.Entry pollFirst() { + public Byte2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstCharValue()); pollFirstByteKey(); return entry; } @Override - public Byte2CharMap.Entry pollLast() { + public Byte2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastCharValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char @Override public boolean moveToLast(byte o) { return Byte2CharArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char @Override public void clear() { Byte2CharArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2CharArrayMap.this.size(); - } - + public int size() { return Byte2CharArrayMap.this.size(); } @Override - public void clear() { - Byte2CharArrayMap.this.clear(); + public void clear() { Byte2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstByteKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2CharMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2CharMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2CharArrayMap extends AbstractByte2CharMap implements Byte2Char public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2DoubleArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2DoubleArrayMap.java index 87e4db5..a20a47f 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2DoubleArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2DoubleOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 return lastValue; } + @Override + public double putFirst(byte key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(byte key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 return result; } + @Override + public Byte2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } @Override - public Byte2DoubleMap.Entry first() { + public Byte2DoubleMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstDoubleValue()); } @Override - public Byte2DoubleMap.Entry last() { + public Byte2DoubleMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastDoubleValue()); } @Override - public Byte2DoubleMap.Entry pollFirst() { + public Byte2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstDoubleValue()); pollFirstByteKey(); return entry; } @Override - public Byte2DoubleMap.Entry pollLast() { + public Byte2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastDoubleValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 @Override public boolean moveToLast(byte o) { return Byte2DoubleArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 @Override public void clear() { Byte2DoubleArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2DoubleArrayMap.this.size(); - } - + public int size() { return Byte2DoubleArrayMap.this.size(); } @Override - public void clear() { - Byte2DoubleArrayMap.this.clear(); + public void clear() { Byte2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstByteKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2DoubleMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2DoubleMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2DoubleArrayMap extends AbstractByte2DoubleMap implements Byte2 public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2FloatArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2FloatArrayMap.java index 8ca091e..d98c1fc 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2FloatArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2FloatOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl return lastValue; } + @Override + public float putFirst(byte key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(byte key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl return result; } + @Override + public Byte2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } @Override - public Byte2FloatMap.Entry first() { + public Byte2FloatMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstFloatValue()); } @Override - public Byte2FloatMap.Entry last() { + public Byte2FloatMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastFloatValue()); } @Override - public Byte2FloatMap.Entry pollFirst() { + public Byte2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstFloatValue()); pollFirstByteKey(); return entry; } @Override - public Byte2FloatMap.Entry pollLast() { + public Byte2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastFloatValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl @Override public boolean moveToLast(byte o) { return Byte2FloatArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl @Override public void clear() { Byte2FloatArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2FloatArrayMap.this.size(); - } - + public int size() { return Byte2FloatArrayMap.this.size(); } @Override - public void clear() { - Byte2FloatArrayMap.this.clear(); + public void clear() { Byte2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstByteKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2FloatMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2FloatMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2FloatArrayMap extends AbstractByte2FloatMap implements Byte2Fl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2IntArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2IntArrayMap.java index 2ab2849..b0acce6 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2IntOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd return lastValue; } + @Override + public int putFirst(byte key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(byte key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd return result; } + @Override + public Byte2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } @Override - public Byte2IntMap.Entry first() { + public Byte2IntMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstIntValue()); } @Override - public Byte2IntMap.Entry last() { + public Byte2IntMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastIntValue()); } @Override - public Byte2IntMap.Entry pollFirst() { + public Byte2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstIntValue()); pollFirstByteKey(); return entry; } @Override - public Byte2IntMap.Entry pollLast() { + public Byte2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastIntValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd @Override public boolean moveToLast(byte o) { return Byte2IntArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd @Override public void clear() { Byte2IntArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2IntArrayMap.this.size(); - } - + public int size() { return Byte2IntArrayMap.this.size(); } @Override - public void clear() { - Byte2IntArrayMap.this.clear(); + public void clear() { Byte2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstByteKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2IntArrayMap extends AbstractByte2IntMap implements Byte2IntOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2LongArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2LongArrayMap.java index 390700b..e1bec08 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2LongArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2LongOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long return lastValue; } + @Override + public long putFirst(byte key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(byte key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long return result; } + @Override + public Byte2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } @Override - public Byte2LongMap.Entry first() { + public Byte2LongMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstLongValue()); } @Override - public Byte2LongMap.Entry last() { + public Byte2LongMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastLongValue()); } @Override - public Byte2LongMap.Entry pollFirst() { + public Byte2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstLongValue()); pollFirstByteKey(); return entry; } @Override - public Byte2LongMap.Entry pollLast() { + public Byte2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastLongValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long @Override public boolean moveToLast(byte o) { return Byte2LongArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long @Override public void clear() { Byte2LongArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2LongArrayMap.this.size(); - } - + public int size() { return Byte2LongArrayMap.this.size(); } @Override - public void clear() { - Byte2LongArrayMap.this.clear(); + public void clear() { Byte2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstByteKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2LongMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2LongMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2LongArrayMap extends AbstractByte2LongMap implements Byte2Long public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ObjectArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ObjectArrayMap.java index a4d6a6a..384a786 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ObjectOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements return lastValue; } + @Override + public V putFirst(byte key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(byte key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements return result; } + @Override + public Byte2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Byte2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(byte key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } @Override - public Byte2ObjectMap.Entry first() { + public Byte2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstByteKey(), firstValue()); } @Override - public Byte2ObjectMap.Entry last() { + public Byte2ObjectMap.Entry getLast() { return new BasicEntry<>(lastByteKey(), lastValue()); } @Override - public Byte2ObjectMap.Entry pollFirst() { + public Byte2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstByteKey(), firstValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ObjectMap.Entry pollLast() { + public Byte2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastByteKey(), lastValue()); pollLastByteKey(); return entry; @@ -656,7 +705,12 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements @Override public boolean moveToLast(byte o) { return Byte2ObjectArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements @Override public void clear() { Byte2ObjectArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ObjectArrayMap.this.size(); - } - + public int size() { return Byte2ObjectArrayMap.this.size(); } @Override - public void clear() { - Byte2ObjectArrayMap.this.clear(); + public void clear() { Byte2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstByteKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1169,6 +1228,9 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Byte2ObjectArrayMap extends AbstractByte2ObjectMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ShortArrayMap.java b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ShortArrayMap.java index 3ccd8ab..b236015 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/impl/misc/Byte2ShortArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.bytes.maps.interfaces.Byte2ShortOrderedMap; import speiger.src.collections.bytes.sets.AbstractByteSet; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -63,7 +63,7 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh /** KeySet cache */ protected ByteOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh return lastValue; } + @Override + public short putFirst(byte key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(byte key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(byte key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh return result; } + @Override + public Byte2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Byte2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Byte2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Byte2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(byte key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } @Override - public Byte2ShortMap.Entry first() { + public Byte2ShortMap.Entry getFirst() { return new BasicEntry(firstByteKey(), firstShortValue()); } @Override - public Byte2ShortMap.Entry last() { + public Byte2ShortMap.Entry getLast() { return new BasicEntry(lastByteKey(), lastShortValue()); } @Override - public Byte2ShortMap.Entry pollFirst() { + public Byte2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstByteKey(), firstShortValue()); pollFirstByteKey(); return entry; } @Override - public Byte2ShortMap.Entry pollLast() { + public Byte2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastByteKey(), lastShortValue()); pollLastByteKey(); return entry; @@ -743,7 +792,12 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh @Override public boolean moveToLast(byte o) { return Byte2ShortArrayMap.this.moveToLast(o); } @Override - public ByteListIterator iterator() { return new KeyIterator(); } + public ByteListIterator iterator() { return new KeyIterator(true); } + @Override + public ByteListIterator reverseIterator() { return new KeyIterator(false); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh @Override public void clear() { Byte2ShortArrayMap.this.clear(); } @Override - public byte firstByte() { return firstByteKey(); } + public byte getFirstByte() { return firstByteKey(); } @Override - public byte pollFirstByte() { return pollFirstByteKey(); } + public byte removeFirstByte() { return pollFirstByteKey(); } @Override - public byte lastByte() { return lastByteKey(); } + public byte getLastByte() { return lastByteKey(); } @Override - public byte pollLastByte() { return pollLastByteKey(); } + public byte removeLastByte() { return pollLastByteKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Byte2ShortArrayMap.this.size(); - } - + public int size() { return Byte2ShortArrayMap.this.size(); } @Override - public void clear() { - Byte2ShortArrayMap.this.clear(); + public void clear() { Byte2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstByteKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastByteKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(byte from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(byte element) { super(element); } @Override public Byte2ShortMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(byte from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(byte element) { super(element); } @Override public Byte2ShortMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } private class KeyIterator extends MapIterator implements ByteListIterator { - public KeyIterator() {} - public KeyIterator(byte element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(byte element) { super(element); } @Override public byte previousByte() { @@ -1256,6 +1315,9 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(byte element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(byte element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Byte2ShortArrayMap extends AbstractByte2ShortMap implements Byte2Sh public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanMap.java index d8ddccc..1c6805f 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanMap.java @@ -94,7 +94,7 @@ public interface Byte2BooleanMap extends Map, BytePredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanOrderedMap.java index 363aa75..a17c3b7 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2BooleanMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2BooleanOrderedMap extends Byte2BooleanMap */ public boolean putAndMoveToLast(byte key, boolean 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 boolean putFirst(byte key, boolean 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 boolean putLast(byte key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2BooleanOrderedMap extends Byte2BooleanMap */ public boolean lastBooleanValue(); + + public Byte2BooleanMap.Entry firstEntry(); + + public Byte2BooleanMap.Entry lastEntry(); + + public Byte2BooleanMap.Entry pollFirstEntry(); + + public Byte2BooleanMap.Entry pollLastEntry(); @Override public Byte2BooleanOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet byte2BooleanEntrySet(); + public default Byte2BooleanOrderedMap reversed() { return new AbstractByte2BooleanMap.ReversedByte2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteMap.java index 74acdd0..8839e69 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteMap.java @@ -93,7 +93,7 @@ public interface Byte2ByteMap extends Map, ByteUnaryOperator * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteOrderedMap.java index 039ff2d..c378d4e 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2ByteMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2ByteOrderedMap extends Byte2ByteMap */ public byte putAndMoveToLast(byte key, byte 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 byte putFirst(byte key, byte 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 byte putLast(byte key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2ByteOrderedMap extends Byte2ByteMap */ public byte lastByteValue(); + + public Byte2ByteMap.Entry firstEntry(); + + public Byte2ByteMap.Entry lastEntry(); + + public Byte2ByteMap.Entry pollFirstEntry(); + + public Byte2ByteMap.Entry pollLastEntry(); @Override public Byte2ByteOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet byte2ByteEntrySet(); + public default Byte2ByteOrderedMap reversed() { return new AbstractByte2ByteMap.ReversedByte2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharMap.java index 986a2e2..a8fc833 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharMap.java @@ -94,7 +94,7 @@ public interface Byte2CharMap extends Map, Byte2CharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharOrderedMap.java index 18aed1a..1e60209 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2CharMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2CharOrderedMap extends Byte2CharMap */ public char putAndMoveToLast(byte key, char 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 char putFirst(byte key, char 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 char putLast(byte key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2CharOrderedMap extends Byte2CharMap */ public char lastCharValue(); + + public Byte2CharMap.Entry firstEntry(); + + public Byte2CharMap.Entry lastEntry(); + + public Byte2CharMap.Entry pollFirstEntry(); + + public Byte2CharMap.Entry pollLastEntry(); @Override public Byte2CharOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet byte2CharEntrySet(); + public default Byte2CharOrderedMap reversed() { return new AbstractByte2CharMap.ReversedByte2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleMap.java index 95fe768..ca2fbbf 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleMap.java @@ -94,7 +94,7 @@ public interface Byte2DoubleMap extends Map, Byte2DoubleFunction * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleOrderedMap.java index c607f89..992691b 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2DoubleMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2DoubleOrderedMap extends Byte2DoubleMap */ public double putAndMoveToLast(byte key, double 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 double putFirst(byte key, double 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 double putLast(byte key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2DoubleOrderedMap extends Byte2DoubleMap */ public double lastDoubleValue(); + + public Byte2DoubleMap.Entry firstEntry(); + + public Byte2DoubleMap.Entry lastEntry(); + + public Byte2DoubleMap.Entry pollFirstEntry(); + + public Byte2DoubleMap.Entry pollLastEntry(); @Override public Byte2DoubleOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet byte2DoubleEntrySet(); + public default Byte2DoubleOrderedMap reversed() { return new AbstractByte2DoubleMap.ReversedByte2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatMap.java index 4c7cee8..a5a26ed 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatMap.java @@ -94,7 +94,7 @@ public interface Byte2FloatMap extends Map, Byte2FloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatOrderedMap.java index affc0cc..4b25368 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2FloatMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2FloatOrderedMap extends Byte2FloatMap */ public float putAndMoveToLast(byte key, float 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 float putFirst(byte key, float 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 float putLast(byte key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2FloatOrderedMap extends Byte2FloatMap */ public float lastFloatValue(); + + public Byte2FloatMap.Entry firstEntry(); + + public Byte2FloatMap.Entry lastEntry(); + + public Byte2FloatMap.Entry pollFirstEntry(); + + public Byte2FloatMap.Entry pollLastEntry(); @Override public Byte2FloatOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet byte2FloatEntrySet(); + public default Byte2FloatOrderedMap reversed() { return new AbstractByte2FloatMap.ReversedByte2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntMap.java index 75be994..bb6d9e5 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntMap.java @@ -94,7 +94,7 @@ public interface Byte2IntMap extends Map, Byte2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntOrderedMap.java index dfe8e27..9c0cacd 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2IntMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2IntOrderedMap extends Byte2IntMap */ public int putAndMoveToLast(byte key, int 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 int putFirst(byte key, int 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 int putLast(byte key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2IntOrderedMap extends Byte2IntMap */ public int lastIntValue(); + + public Byte2IntMap.Entry firstEntry(); + + public Byte2IntMap.Entry lastEntry(); + + public Byte2IntMap.Entry pollFirstEntry(); + + public Byte2IntMap.Entry pollLastEntry(); @Override public Byte2IntOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet byte2IntEntrySet(); + public default Byte2IntOrderedMap reversed() { return new AbstractByte2IntMap.ReversedByte2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongMap.java index 8893020..2ffa460 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongMap.java @@ -94,7 +94,7 @@ public interface Byte2LongMap extends Map, Byte2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongOrderedMap.java index 940de4b..c2c0b15 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2LongMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2LongOrderedMap extends Byte2LongMap */ public long putAndMoveToLast(byte key, long 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 long putFirst(byte key, long 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 long putLast(byte key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2LongOrderedMap extends Byte2LongMap */ public long lastLongValue(); + + public Byte2LongMap.Entry firstEntry(); + + public Byte2LongMap.Entry lastEntry(); + + public Byte2LongMap.Entry pollFirstEntry(); + + public Byte2LongMap.Entry pollLastEntry(); @Override public Byte2LongOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet byte2LongEntrySet(); + public default Byte2LongOrderedMap reversed() { return new AbstractByte2LongMap.ReversedByte2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectMap.java index f1145bd..b6af3ec 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectMap.java @@ -95,7 +95,7 @@ public interface Byte2ObjectMap extends Map, ByteFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectOrderedMap.java index f49399f..5f35584 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2ObjectMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Byte2ObjectOrderedMap extends Byte2ObjectMap */ public V putAndMoveToLast(byte key, V 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 V putFirst(byte key, V 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 V putLast(byte key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Byte2ObjectOrderedMap extends Byte2ObjectMap */ public V lastValue(); + + public Byte2ObjectMap.Entry firstEntry(); + + public Byte2ObjectMap.Entry lastEntry(); + + public Byte2ObjectMap.Entry pollFirstEntry(); + + public Byte2ObjectMap.Entry pollLastEntry(); @Override public Byte2ObjectOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> byte2ObjectEntrySet(); + public default Byte2ObjectOrderedMap reversed() { return new AbstractByte2ObjectMap.ReversedByte2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortMap.java index 88225d1..b7e7ff0 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortMap.java @@ -94,7 +94,7 @@ public interface Byte2ShortMap extends Map, Byte2ShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().byteValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortOrderedMap.java b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortOrderedMap.java index ec16640..4ffcddc 100644 --- a/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/bytes/maps/interfaces/Byte2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.bytes.maps.interfaces; import speiger.src.collections.bytes.utils.maps.Byte2ShortMaps; +import speiger.src.collections.bytes.maps.abstracts.AbstractByte2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Byte2ShortOrderedMap extends Byte2ShortMap */ public short putAndMoveToLast(byte key, short 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 short putFirst(byte key, short 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 short putLast(byte key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Byte2ShortOrderedMap extends Byte2ShortMap */ public short lastShortValue(); + + public Byte2ShortMap.Entry firstEntry(); + + public Byte2ShortMap.Entry lastEntry(); + + public Byte2ShortMap.Entry pollFirstEntry(); + + public Byte2ShortMap.Entry pollLastEntry(); @Override public Byte2ShortOrderedMap copy(); @Override public ByteOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet byte2ShortEntrySet(); + public default Byte2ShortOrderedMap reversed() { return new AbstractByte2ShortMap.ReversedByte2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/sets/AbstractByteSet.java b/src/main/java/speiger/src/collections/bytes/sets/AbstractByteSet.java index 1d164d9..ac4197a 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/AbstractByteSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/AbstractByteSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.bytes.sets; import java.util.Set; import speiger.src.collections.bytes.collections.AbstractByteCollection; +import speiger.src.collections.bytes.collections.ByteBidirectionalIterator; import speiger.src.collections.bytes.collections.ByteIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractByteSet extends AbstractByteCollection implements return false; } } + + public static class ReversedByteOrderedSet extends AbstractByteSet implements ByteOrderedSet { + protected ByteOrderedSet set; + + public ReversedByteOrderedSet(ByteOrderedSet set) { + this.set = set; + } + + @Override + public ReversedByteOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public ByteBidirectionalIterator iterator(byte fromElement) { + return set.iterator(fromElement); + } + + @Override + public ByteBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public ByteBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(byte o) { + return set.remove(o); + } + + @Override + public boolean add(byte o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(byte o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(byte o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(byte o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(byte o) { + return set.moveToFirst(o); + } + + @Override + public byte getFirstByte() { + return set.getLastByte(); + } + + @Override + public byte removeFirstByte() { + return set.removeLastByte(); + } + + @Override + public byte getLastByte() { + return set.getFirstByte(); + } + + @Override + public byte removeLastByte() { + return set.removeFirstByte(); + } + + @Override + public ByteOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteArraySet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteArraySet.java index b02b0ab..87efb44 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteArraySet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteArraySet.java @@ -186,13 +186,13 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet } @Override - public byte firstByte() { + public byte getFirstByte() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public byte lastByte() { + public byte getLastByte() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -283,7 +283,7 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { if(size == 0) throw new NoSuchElementException(); byte result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -291,7 +291,7 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet } @Override - public byte pollLastByte() { + public byte removeLastByte() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -414,13 +414,18 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet @Override public ByteBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public ByteBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public ByteBidirectionalIterator iterator(byte fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -471,45 +476,57 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet } private class SetIterator implements ByteListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public byte nextByte() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public byte previousByte() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -529,15 +546,23 @@ public class ByteArraySet extends AbstractByteSet implements ByteOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenCustomHashSet.java index f9aeb57..b1cf628 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public boolean moveToFirst(byte o) { - if(isEmpty() || strategy.equals(firstByte(), o)) return false; + if(isEmpty() || strategy.equals(getFirstByte(), o)) return false; if(strategy.equals(o, (byte)0)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public boolean moveToLast(byte o) { - if(isEmpty() || strategy.equals(lastByte(), o)) return false; + if(isEmpty() || strategy.equals(getLastByte(), o)) return false; if(strategy.equals(o, (byte)0)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement } @Override - public byte firstByte() { + public byte getFirstByte() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement } @Override - public byte lastByte() { + public byte getLastByte() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public byte pollLastByte() { + public byte removeLastByte() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public ByteListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement } private class SetIterator implements ByteListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(byte from) { + this.forward = true; if(strategy.equals(from, (byte)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public byte previousByte() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class ByteLinkedOpenCustomHashSet extends ByteOpenCustomHashSet implement @Override public byte nextByte() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenHashSet.java index 5f3af4c..f37a4f9 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public boolean moveToFirst(byte o) { - if(isEmpty() || firstByte() == o) return false; + if(isEmpty() || getFirstByte() == o) return false; if(o == (byte)0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public boolean moveToLast(byte o) { - if(isEmpty() || lastByte() == o) return false; + if(isEmpty() || getLastByte() == o) return false; if(o == (byte)0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere } @Override - public byte firstByte() { + public byte getFirstByte() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public byte pollFirstByte() { + public byte removeFirstByte() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere } @Override - public byte lastByte() { + public byte getLastByte() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public byte pollLastByte() { + public byte removeLastByte() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public ByteListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere } private class SetIterator implements ByteListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(byte from) { + this.forward = true; if(from == (byte)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public byte previousByte() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class ByteLinkedOpenHashSet extends ByteOpenHashSet implements ByteOrdere @Override public byte nextByte() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteNavigableSet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteNavigableSet.java index e447e3e..4aa2736 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteNavigableSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.bytes.collections.ByteBidirectionalIterator; import speiger.src.collections.bytes.collections.ByteSplititerator; -import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.bytes.utils.ByteSplititerators; +import speiger.src.collections.bytes.utils.ByteSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteOrderedSet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteOrderedSet.java index 2efb647..8e04175 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteOrderedSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.bytes.sets; import speiger.src.collections.bytes.collections.ByteBidirectionalIterator; import speiger.src.collections.bytes.collections.ByteSplititerator; -import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.bytes.utils.ByteSplititerators; +import speiger.src.collections.bytes.sets.AbstractByteSet.ReversedByteOrderedSet; +import speiger.src.collections.bytes.utils.ByteSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface ByteOrderedSet extends ByteSet @Override public ByteBidirectionalIterator iterator(); + public ByteBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface ByteOrderedSet extends ByteSet * A method to get the first element in the set * @return first element in the set */ - public byte firstByte(); + public byte getFirstByte(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public byte pollFirstByte(); + public byte removeFirstByte(); /** * A method to get the last element in the set * @return last element in the set */ - public byte lastByte(); + public byte getLastByte(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public byte pollLastByte(); + public byte removeLastByte(); + + public default ByteOrderedSet reversed() { return new ReversedByteOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/bytes/sets/ByteSet.java b/src/main/java/speiger/src/collections/bytes/sets/ByteSet.java index 3f332f1..98f9bdb 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ByteSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ByteSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.bytes.collections.ByteCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.collections.ByteSplititerator; -import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.bytes.utils.ByteSplititerators; +import speiger.src.collections.bytes.utils.ByteSets; /** diff --git a/src/main/java/speiger/src/collections/bytes/sets/ImmutableByteOpenHashSet.java b/src/main/java/speiger/src/collections/bytes/sets/ImmutableByteOpenHashSet.java index 883f52f..d503ef8 100644 --- a/src/main/java/speiger/src/collections/bytes/sets/ImmutableByteOpenHashSet.java +++ b/src/main/java/speiger/src/collections/bytes/sets/ImmutableByteOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd } @Override - public byte firstByte() { + public byte getFirstByte() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { + public byte getLastByte() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd @Override public ByteListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ByteListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd } private class SetIterator implements ByteListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(byte from) { + this.forward = true; if(from == (byte)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd @Override public byte previousByte() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableByteOpenHashSet extends AbstractByteSet implements ByteOrd @Override public byte nextByte() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/bytes/utils/ByteCollections.java b/src/main/java/speiger/src/collections/bytes/utils/ByteCollections.java index da85b0d..a2b327a 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/ByteCollections.java +++ b/src/main/java/speiger/src/collections/bytes/utils/ByteCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.bytes.collections.AbstractByteCollection; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -51,6 +52,34 @@ public class ByteCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static ByteOrderedCollection unmodifiable(ByteOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ByteOrderedCollection synchronize(ByteOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ByteOrderedCollection synchronize(ByteOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -584,6 +613,37 @@ public class ByteCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements ByteOrderedCollection { + ByteOrderedCollection c; + + SynchronizedOrderedCollection(ByteOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(ByteOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ByteOrderedCollection reversed() { return ByteCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(byte e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(byte e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public byte getFirstByte() { synchronized(mutex) { return this.c.getFirstByte(); } } + @Override + public byte removeFirstByte() { synchronized(mutex) { return this.c.removeFirstByte(); } } + @Override + public byte getLastByte() { synchronized(mutex) { return this.c.getLastByte(); } } + @Override + public byte removeLastByte() { synchronized(mutex) { return this.c.removeLastByte(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -705,6 +765,33 @@ public class ByteCollections public int count(BytePredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements ByteOrderedCollection { + ByteOrderedCollection c; + + UnmodifiableOrderedCollection(ByteOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ByteOrderedCollection reversed() { return ByteCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return c.getFirstByte(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return c.getLastByte(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/bytes/utils/ByteIterators.java b/src/main/java/speiger/src/collections/bytes/utils/ByteIterators.java index f7945f2..a20b255 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/ByteIterators.java +++ b/src/main/java/speiger/src/collections/bytes/utils/ByteIterators.java @@ -34,7 +34,7 @@ public class ByteIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static ByteListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class ByteIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(byte... a) { + public static ByteIterator wrap(byte... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class ByteIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(byte[] a, int start, int end) { + public static ByteIterator wrap(byte[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/bytes/utils/ByteLists.java b/src/main/java/speiger/src/collections/bytes/utils/ByteLists.java index 29f3c31..9f3061f 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/ByteLists.java +++ b/src/main/java/speiger/src/collections/bytes/utils/ByteLists.java @@ -30,7 +30,7 @@ public class ByteLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static ByteList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/bytes/utils/ByteSets.java b/src/main/java/speiger/src/collections/bytes/utils/ByteSets.java index e2879d7..53d3055 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/ByteSets.java +++ b/src/main/java/speiger/src/collections/bytes/utils/ByteSets.java @@ -312,17 +312,19 @@ public class ByteSets @Override public ByteBidirectionalIterator iterator() { return ByteIterators.unmodifiable(s.iterator()); } @Override + public ByteBidirectionalIterator reverseIterator() { return ByteIterators.unmodifiable(s.reverseIterator()); } + @Override public ByteBidirectionalIterator iterator(byte fromElement) { return ByteIterators.unmodifiable(s.iterator(fromElement)); } @Override public ByteOrderedSet copy() { return s.copy(); } @Override - public byte firstByte() { return s.firstByte(); } + public byte getFirstByte() { return s.getFirstByte(); } @Override - public byte pollFirstByte() { throw new UnsupportedOperationException(); } + public byte removeFirstByte() { throw new UnsupportedOperationException(); } @Override - public byte lastByte() { return s.lastByte(); } + public byte getLastByte() { return s.getLastByte(); } @Override - public byte pollLastByte() { throw new UnsupportedOperationException(); } + public byte removeLastByte() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements ByteSortedSet @@ -583,17 +585,19 @@ public class ByteSets @Override public ByteBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public ByteBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public ByteBidirectionalIterator iterator(byte fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public ByteOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public byte firstByte() { synchronized(mutex) { return s.firstByte(); } } + public byte getFirstByte() { synchronized(mutex) { return s.getFirstByte(); } } @Override - public byte pollFirstByte() { synchronized(mutex) { return s.pollFirstByte(); } } + public byte removeFirstByte() { synchronized(mutex) { return s.removeFirstByte(); } } @Override - public byte lastByte() { synchronized(mutex) { return s.lastByte(); } } + public byte getLastByte() { synchronized(mutex) { return s.getLastByte(); } } @Override - public byte pollLastByte() { synchronized(mutex) { return s.pollLastByte(); } } + public byte removeLastByte() { synchronized(mutex) { return s.removeLastByte(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2BooleanMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2BooleanMaps.java index 42442f2..16ecbf4 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Byte2BooleanMaps @Override public boolean putAndMoveToLast(byte key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(byte key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(byte key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Byte2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Byte2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2BooleanOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet byte2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Byte2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2BooleanMap.Entry first() { return set.first(); } + public Byte2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2BooleanMap.Entry last() { return set.last(); } + public Byte2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Byte2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Byte2BooleanMaps @Override public boolean putAndMoveToLast(byte key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(byte key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(byte key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Byte2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Byte2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet byte2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ByteMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ByteMaps.java index 8bb6a3f..06e0f8d 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ByteMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -438,6 +439,10 @@ public class Byte2ByteMaps @Override public byte putAndMoveToLast(byte key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(byte key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(byte key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Byte2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Byte2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2ByteOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet byte2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2ByteEntrySet()); @@ -616,15 +633,17 @@ public class Byte2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2ByteMap.Entry first() { return set.first(); } + public Byte2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ByteMap.Entry last() { return set.last(); } + public Byte2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Byte2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Byte2ByteMaps @Override public byte putAndMoveToLast(byte key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(byte key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(byte key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Byte2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Byte2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet byte2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2CharMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2CharMaps.java index 3a92fc4..8f3817d 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2CharMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Byte2CharMaps @Override public char putAndMoveToLast(byte key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(byte key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(byte key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Byte2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2CharOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet byte2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2CharEntrySet()); @@ -617,15 +634,17 @@ public class Byte2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2CharMap.Entry first() { return set.first(); } + public Byte2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2CharMap.Entry last() { return set.last(); } + public Byte2CharMap.Entry getLast() { return set.getLast(); } @Override - public Byte2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2CharMaps @Override public char putAndMoveToLast(byte key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(byte key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(byte key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Byte2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet byte2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2DoubleMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2DoubleMaps.java index 3023370..f8bdbc5 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Byte2DoubleMaps @Override public double putAndMoveToLast(byte key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(byte key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(byte key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Byte2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2DoubleOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet byte2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Byte2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2DoubleMap.Entry first() { return set.first(); } + public Byte2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2DoubleMap.Entry last() { return set.last(); } + public Byte2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Byte2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2DoubleMaps @Override public double putAndMoveToLast(byte key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(byte key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(byte key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Byte2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet byte2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2FloatMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2FloatMaps.java index 4bfd042..aab5bd7 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2FloatMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Byte2FloatMaps @Override public float putAndMoveToLast(byte key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(byte key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(byte key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Byte2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2FloatOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet byte2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Byte2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2FloatMap.Entry first() { return set.first(); } + public Byte2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2FloatMap.Entry last() { return set.last(); } + public Byte2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Byte2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2FloatMaps @Override public float putAndMoveToLast(byte key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(byte key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(byte key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Byte2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet byte2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2IntMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2IntMaps.java index 78a456a..2a6c866 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2IntMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Byte2IntMaps @Override public int putAndMoveToLast(byte key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(byte key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(byte key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Byte2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2IntOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet byte2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2IntEntrySet()); @@ -617,15 +634,17 @@ public class Byte2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2IntMap.Entry first() { return set.first(); } + public Byte2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2IntMap.Entry last() { return set.last(); } + public Byte2IntMap.Entry getLast() { return set.getLast(); } @Override - public Byte2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2IntMaps @Override public int putAndMoveToLast(byte key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(byte key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(byte key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Byte2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet byte2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2LongMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2LongMaps.java index 2dcde03..8af841c 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2LongMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Byte2LongMaps @Override public long putAndMoveToLast(byte key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(byte key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(byte key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Byte2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2LongOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet byte2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2LongEntrySet()); @@ -617,15 +634,17 @@ public class Byte2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2LongMap.Entry first() { return set.first(); } + public Byte2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2LongMap.Entry last() { return set.last(); } + public Byte2LongMap.Entry getLast() { return set.getLast(); } @Override - public Byte2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2LongMaps @Override public long putAndMoveToLast(byte key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(byte key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(byte key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Byte2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet byte2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ObjectMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ObjectMaps.java index d926d88..d8e5c22 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Byte2ObjectMaps @Override public V putAndMoveToLast(byte key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(byte key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(byte key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Byte2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2ObjectOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> byte2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.byte2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Byte2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Byte2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2ObjectMap.Entry first() { return set.first(); } + public Byte2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ObjectMap.Entry last() { return set.last(); } + public Byte2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Byte2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Byte2ObjectMaps @Override public V putAndMoveToLast(byte key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(byte key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(byte key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Byte2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Byte2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> byte2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ShortMaps.java b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ShortMaps.java index 0c73b7e..c9ef49a 100644 --- a/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ShortMaps.java +++ b/src/main/java/speiger/src/collections/bytes/utils/maps/Byte2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.bytes.sets.ByteOrderedSet; import speiger.src.collections.bytes.sets.ByteSet; import speiger.src.collections.bytes.utils.ByteSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Byte2ShortMaps @Override public short putAndMoveToLast(byte key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(byte key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(byte key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(byte key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(byte key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Byte2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Byte2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Byte2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Byte2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Byte2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Byte2ShortOrderedMap copy() { return map.copy(); } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.unmodifiable(map.keySet()); return (ByteOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet byte2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.byte2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Byte2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Byte2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Byte2ShortMap.Entry first() { return set.first(); } + public Byte2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Byte2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Byte2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Byte2ShortMap.Entry last() { return set.last(); } + public Byte2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Byte2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Byte2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Byte2ShortMaps @Override public short putAndMoveToLast(byte key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(byte key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(byte key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(byte key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(byte key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Byte2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Byte2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Byte2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Byte2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Byte2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Byte2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ByteOrderedSet keySet() { if(keys == null) keys = ByteSets.synchronize(map.keySet(), mutex); return (ByteOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet byte2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.byte2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/collections/AbstractCharCollection.java b/src/main/java/speiger/src/collections/chars/collections/AbstractCharCollection.java index 903c32c..5094bfc 100644 --- a/src/main/java/speiger/src/collections/chars/collections/AbstractCharCollection.java +++ b/src/main/java/speiger/src/collections/chars/collections/AbstractCharCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.chars.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.chars.lists.CharListIterator; import speiger.src.collections.chars.functions.CharConsumer; import speiger.src.collections.chars.utils.CharIterators; import speiger.src.collections.chars.utils.CharArrays; @@ -249,4 +251,68 @@ public abstract class AbstractCharCollection extends AbstractCollection size()) a[size()] = (char)0; return a; } + + public static class ReverseCharOrderedCollection extends AbstractCharCollection implements CharOrderedCollection { + CharOrderedCollection collection; + Supplier reverseIterator; + + public ReverseCharOrderedCollection(CharOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(char o) { return collection.add(o); } + @Override + public CharOrderedCollection reversed() { return collection; } + @Override + public void addFirst(char e) { collection.addLast(e); } + @Override + public void addLast(char e) { collection.addFirst(e); } + @Override + public boolean contains(char e) { return collection.contains(e); } + @Override + public boolean remChar(char e) { return collection.remChar(e); } + @Override + public void clear() { collection.clear(); } + @Override + public char getFirstChar() { return collection.getLastChar(); } + @Override + public char removeFirstChar() { return collection.removeLastChar(); } + @Override + public char getLastChar() { return collection.getFirstChar(); } + @Override + public char removeLastChar() { return collection.removeFirstChar(); } + @Override + public CharIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements CharListIterator { + CharListIterator it; + + public ReverseBiIterator(CharListIterator it) { + this.it = it; + } + + @Override + public char nextChar() { return it.previousChar(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public char previousChar() { return it.nextChar(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(char e) { it.set(e); } + @Override + public void add(char e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/chars/collections/CharBidirectionalIterator.java b/src/main/java/speiger/src/collections/chars/collections/CharBidirectionalIterator.java index 3746b44..9c4535c 100644 --- a/src/main/java/speiger/src/collections/chars/collections/CharBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/chars/collections/CharBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.chars.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface CharBidirectionalIterator extends CharIterator, ObjectBidirectionalIterator +public interface CharBidirectionalIterator extends CharIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface CharBidirectionalIterator extends CharIterator, ObjectBidirecti */ public char previousChar(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Character previous() { return Character.valueOf(previousChar()); diff --git a/src/main/java/speiger/src/collections/chars/collections/CharOrderedCollection.java b/src/main/java/speiger/src/collections/chars/collections/CharOrderedCollection.java new file mode 100644 index 0000000..7ba3199 --- /dev/null +++ b/src/main/java/speiger/src/collections/chars/collections/CharOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.chars.collections; + +public interface CharOrderedCollection extends CharCollection { + + CharOrderedCollection 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(char 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(char e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public char getFirstChar(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public char removeFirstChar(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public char getLastChar(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public char removeLastChar(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/chars/lists/AbstractCharList.java b/src/main/java/speiger/src/collections/chars/lists/AbstractCharList.java index db99397..9332a11 100644 --- a/src/main/java/speiger/src/collections/chars/lists/AbstractCharList.java +++ b/src/main/java/speiger/src/collections/chars/lists/AbstractCharList.java @@ -466,7 +466,6 @@ public abstract class AbstractCharList extends AbstractCharCollection implements public int size() { return size; } - @Override public CharSplititerator spliterator() { return CharSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/chars/lists/CharLinkedList.java b/src/main/java/speiger/src/collections/chars/lists/CharLinkedList.java index 1328312..fcfea62 100644 --- a/src/main/java/speiger/src/collections/chars/lists/CharLinkedList.java +++ b/src/main/java/speiger/src/collections/chars/lists/CharLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.chars.functions.CharConsumer; import speiger.src.collections.chars.utils.CharArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.IntStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.chars.collections.CharSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.chars.collections.CharSplititerator; import speiger.src.collections.chars.utils.CharSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class CharLinkedList extends AbstractCharList implements CharPriorityDequ if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class CharLinkedList extends AbstractCharList implements CharPriorityDequ * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } - /** + public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/chars/lists/CharList.java b/src/main/java/speiger/src/collections/chars/lists/CharList.java index 6d86715..a5b7eb8 100644 --- a/src/main/java/speiger/src/collections/chars/lists/CharList.java +++ b/src/main/java/speiger/src/collections/chars/lists/CharList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharSplititerator; import speiger.src.collections.ints.functions.consumer.IntCharConsumer; import speiger.src.collections.chars.functions.CharComparator; @@ -21,7 +22,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 */ -public interface CharList extends CharCollection, List +public interface CharList extends CharOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -84,6 +85,24 @@ public interface CharList extends CharCollection, List */ public boolean addAll(int index, CharList 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(char 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(char e) { + add(e); + } + /** * 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. @@ -414,9 +433,9 @@ public interface CharList extends CharCollection, List @Override @Deprecated public default boolean add(Character e) { - return CharCollection.super.add(e); + return CharOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -464,7 +483,7 @@ public interface CharList extends CharCollection, List @Override @Deprecated public default boolean contains(Object o) { - return CharCollection.super.contains(o); + return CharOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -474,7 +493,7 @@ public interface CharList extends CharCollection, List @Override @Deprecated public default boolean remove(Object o) { - return CharCollection.super.remove(o); + return CharOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2BooleanMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2BooleanMap.java index f1df355..cb4b472 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2BooleanMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharBooleanConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.chars.functions.function.CharBooleanUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2BooleanMap; +import speiger.src.collections.chars.maps.interfaces.Char2BooleanOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractChar2BooleanMap extends AbstractMap char2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2BooleanEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ByteMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ByteMap.java index 7e7e4bc..7812441 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ByteMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharByteConsumer; import speiger.src.collections.chars.functions.function.Char2ByteFunction; import speiger.src.collections.chars.functions.function.CharByteUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2ByteMap; +import speiger.src.collections.chars.maps.interfaces.Char2ByteOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2ByteMap extends AbstractMap implements Char2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2ByteMap extends AbstractMap public void putAll(Character[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedChar2ByteOrderedMap extends AbstractChar2ByteMap implements Char2ByteOrderedMap { + Char2ByteOrderedMap map; + + public ReversedChar2ByteOrderedMap(Char2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractChar2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Char2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(char key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(char key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(char key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(char key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(char key) { return map.remove(key); } + @Override + public boolean remove(char key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(char key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(char key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(char key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(char key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Char2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(CharByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(char key, CharByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(char key, Char2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(char key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(char key, CharByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(char key, CharByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(char key, Char2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(char key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(char key, CharByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(char key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(char key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(char key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(char key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(char key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(char key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(char key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(char key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(char key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(char key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(char key) { return map.getAndMoveToFirst(key); } + @Override + public char firstCharKey() { return map.lastCharKey(); } + @Override + public char pollFirstCharKey() { return map.pollLastCharKey(); } + @Override + public char lastCharKey() { return map.firstCharKey(); } + @Override + public char pollLastCharKey() { return map.pollFirstCharKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Char2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Char2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Char2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Char2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet char2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2ByteEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2CharMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2CharMap.java index 9d6a53d..4a15786 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2CharMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharCharConsumer; import speiger.src.collections.chars.functions.function.CharUnaryOperator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2CharMap; +import speiger.src.collections.chars.maps.interfaces.Char2CharOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2CharMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2CharMap extends AbstractMap implements Char2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractChar2CharMap extends AbstractMap char2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2CharEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2DoubleMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2DoubleMap.java index acc6d85..c18afae 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2DoubleMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharDoubleConsumer; import speiger.src.collections.chars.functions.function.Char2DoubleFunction; import speiger.src.collections.chars.functions.function.CharDoubleUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2DoubleMap; +import speiger.src.collections.chars.maps.interfaces.Char2DoubleOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2DoubleMap extends AbstractMap implements Char2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2DoubleMap extends AbstractMap char2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2DoubleEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2FloatMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2FloatMap.java index 358202b..a3988d2 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2FloatMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharFloatConsumer; import speiger.src.collections.chars.functions.function.Char2FloatFunction; import speiger.src.collections.chars.functions.function.CharFloatUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2FloatMap; +import speiger.src.collections.chars.maps.interfaces.Char2FloatOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2FloatMap extends AbstractMap implements Char2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2FloatMap extends AbstractMap char2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2FloatEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2IntMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2IntMap.java index 34c7a3f..848a6af 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2IntMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharIntConsumer; import speiger.src.collections.chars.functions.function.Char2IntFunction; import speiger.src.collections.chars.functions.function.CharIntUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2IntMap; +import speiger.src.collections.chars.maps.interfaces.Char2IntOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2IntMap extends AbstractMap implements Char2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2IntMap extends AbstractMap char2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2IntEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2LongMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2LongMap.java index b6013f6..6861633 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2LongMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharLongConsumer; import speiger.src.collections.chars.functions.function.Char2LongFunction; import speiger.src.collections.chars.functions.function.CharLongUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2LongMap; +import speiger.src.collections.chars.maps.interfaces.Char2LongOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2LongMap extends AbstractMap implements Char2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2LongMap extends AbstractMap public void putAll(Character[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedChar2LongOrderedMap extends AbstractChar2LongMap implements Char2LongOrderedMap { + Char2LongOrderedMap map; + + public ReversedChar2LongOrderedMap(Char2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractChar2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Char2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(char key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(char key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(char key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(char key, long value) { return map.subFrom(key, value); } + @Override + public long remove(char key) { return map.remove(key); } + @Override + public boolean remove(char key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(char key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(char key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(char key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(char key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Char2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(CharLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(char key, CharLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(char key, Char2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(char key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(char key, CharLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(char key, CharLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(char key, Char2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(char key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(char key, CharLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(char key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(char key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(char key) { return map.get(key); } + @Override + public long putAndMoveToFirst(char key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(char key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(char key, long value) { return map.putLast(key, value); } + @Override + public long putLast(char key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(char key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(char key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(char key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(char key) { return map.getAndMoveToFirst(key); } + @Override + public char firstCharKey() { return map.lastCharKey(); } + @Override + public char pollFirstCharKey() { return map.pollLastCharKey(); } + @Override + public char lastCharKey() { return map.firstCharKey(); } + @Override + public char pollLastCharKey() { return map.pollFirstCharKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Char2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Char2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Char2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Char2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet char2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2LongEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ObjectMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ObjectMap.java index 97b3cdc..df16d62 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ObjectMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharObjectConsumer; import speiger.src.collections.chars.functions.function.CharFunction; import speiger.src.collections.chars.functions.function.CharObjectUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2ObjectMap; +import speiger.src.collections.chars.maps.interfaces.Char2ObjectOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractChar2ObjectMap extends AbstractMap extends AbstractMap extends AbstractChar2ObjectMap implements Char2ObjectOrderedMap { + Char2ObjectOrderedMap map; + + public ReversedChar2ObjectOrderedMap(Char2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractChar2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Char2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(char key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(char key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(char key) { return map.remove(key); } + @Override + public boolean remove(char key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(char key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(char key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(char key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(char key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Char2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(CharObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(char key, CharObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(char key, CharFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(char key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(char key, CharObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(char key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(char key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(char key) { return map.get(key); } + @Override + public V putAndMoveToFirst(char key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(char key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(char key, V value) { return map.putLast(key, value); } + @Override + public V putLast(char key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(char key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(char key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(char key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(char key) { return map.getAndMoveToFirst(key); } + @Override + public char firstCharKey() { return map.lastCharKey(); } + @Override + public char pollFirstCharKey() { return map.pollLastCharKey(); } + @Override + public char lastCharKey() { return map.firstCharKey(); } + @Override + public char pollLastCharKey() { return map.pollFirstCharKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Char2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Char2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Char2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Char2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> char2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2ObjectEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ShortMap.java b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ShortMap.java index 56518fc..2301fef 100644 --- a/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ShortMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/abstracts/AbstractChar2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.chars.functions.consumer.CharShortConsumer; import speiger.src.collections.chars.functions.function.Char2ShortFunction; import speiger.src.collections.chars.functions.function.CharShortUnaryOperator; import speiger.src.collections.chars.maps.interfaces.Char2ShortMap; +import speiger.src.collections.chars.maps.interfaces.Char2ShortOrderedMap; +import speiger.src.collections.chars.sets.CharOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.maps.Char2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractChar2ShortMap extends AbstractMap implements Char2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractChar2ShortMap extends AbstractMap char2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.char2ShortEntrySet()); } + @Override + public CharOrderedSet keySet() { return new AbstractCharSet.ReversedCharOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Char2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2BooleanLinkedOpenCustomHashMap.java index 1d30180..5a706aa 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH return getDefaultReturnValue(); } + @Override + public boolean putFirst(char key, boolean value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 boolean putLast(char key, boolean value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH return values[lastIndex]; } + @Override + public Char2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } @Override - public Char2BooleanMap.Entry first() { + public Char2BooleanMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstBooleanValue()); } @Override - public Char2BooleanMap.Entry last() { + public Char2BooleanMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastBooleanValue()); } @Override - public Char2BooleanMap.Entry pollFirst() { + public Char2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstBooleanValue()); pollFirstCharKey(); return entry; } @Override - public Char2BooleanMap.Entry pollLast() { + public Char2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastBooleanValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstCharKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Char2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2BooleanLinkedOpenCustomHashMap extends Char2BooleanOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ByteLinkedOpenCustomHashMap.java index 44d9507..ed2799d 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ByteLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -258,6 +258,54 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public byte putFirst(char key, byte value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 byte putLast(char key, byte value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap return values[lastIndex]; } + @Override + public Char2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } @Override - public Char2ByteMap.Entry first() { + public Char2ByteMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstByteValue()); } @Override - public Char2ByteMap.Entry last() { + public Char2ByteMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastByteValue()); } @Override - public Char2ByteMap.Entry pollFirst() { + public Char2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstByteValue()); pollFirstCharKey(); return entry; } @Override - public Char2ByteMap.Entry pollLast() { + public Char2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastByteValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstCharKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Char2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1284,16 +1399,20 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2ByteLinkedOpenCustomHashMap extends Char2ByteOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2CharLinkedOpenCustomHashMap.java index 44ec6d1..cd92f99 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2CharLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public char putFirst(char key, char value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 char putLast(char key, char value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -386,6 +434,52 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap return values[lastIndex]; } + @Override + public Char2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } @Override - public Char2CharMap.Entry first() { + public Char2CharMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstCharValue()); } @Override - public Char2CharMap.Entry last() { + public Char2CharMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastCharValue()); } @Override - public Char2CharMap.Entry pollFirst() { + public Char2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstCharValue()); pollFirstCharKey(); return entry; } @Override - public Char2CharMap.Entry pollLast() { + public Char2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastCharValue()); pollLastCharKey(); return entry; @@ -611,7 +705,12 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1023,30 +1127,41 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstCharKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Char2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastCharKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1204,7 +1319,7 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1234,7 +1349,7 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1256,7 +1371,7 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1277,16 +1392,20 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Char2CharLinkedOpenCustomHashMap extends Char2CharOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2DoubleLinkedOpenCustomHashMap.java index 1b5bea5..78abcc2 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2DoubleLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -258,6 +258,54 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas return getDefaultReturnValue(); } + @Override + public double putFirst(char key, double value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 double putLast(char key, double value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas return values[lastIndex]; } + @Override + public Char2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } @Override - public Char2DoubleMap.Entry first() { + public Char2DoubleMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstDoubleValue()); } @Override - public Char2DoubleMap.Entry last() { + public Char2DoubleMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastDoubleValue()); } @Override - public Char2DoubleMap.Entry pollFirst() { + public Char2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstDoubleValue()); pollFirstCharKey(); return entry; } @Override - public Char2DoubleMap.Entry pollLast() { + public Char2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastDoubleValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstCharKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Char2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1284,16 +1399,20 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2DoubleLinkedOpenCustomHashMap extends Char2DoubleOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2FloatLinkedOpenCustomHashMap.java index 75ef742..488c7d3 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2FloatLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -258,6 +258,54 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM return getDefaultReturnValue(); } + @Override + public float putFirst(char key, float value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 float putLast(char key, float value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM return values[lastIndex]; } + @Override + public Char2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } @Override - public Char2FloatMap.Entry first() { + public Char2FloatMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstFloatValue()); } @Override - public Char2FloatMap.Entry last() { + public Char2FloatMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastFloatValue()); } @Override - public Char2FloatMap.Entry pollFirst() { + public Char2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstFloatValue()); pollFirstCharKey(); return entry; } @Override - public Char2FloatMap.Entry pollLast() { + public Char2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastFloatValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstCharKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Char2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1284,16 +1399,20 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2FloatLinkedOpenCustomHashMap extends Char2FloatOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2IntLinkedOpenCustomHashMap.java index 815178d..9b40a08 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public int putFirst(char key, int value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 int putLast(char key, int value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i return values[lastIndex]; } + @Override + public Char2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } @Override - public Char2IntMap.Entry first() { + public Char2IntMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstIntValue()); } @Override - public Char2IntMap.Entry last() { + public Char2IntMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastIntValue()); } @Override - public Char2IntMap.Entry pollFirst() { + public Char2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstIntValue()); pollFirstCharKey(); return entry; } @Override - public Char2IntMap.Entry pollLast() { + public Char2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastIntValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstCharKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Char2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2IntLinkedOpenCustomHashMap extends Char2IntOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2LongLinkedOpenCustomHashMap.java index da635f9..3253b35 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2LongLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -258,6 +258,54 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public long putFirst(char key, long value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 long putLast(char key, long value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap return values[lastIndex]; } + @Override + public Char2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } @Override - public Char2LongMap.Entry first() { + public Char2LongMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstLongValue()); } @Override - public Char2LongMap.Entry last() { + public Char2LongMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastLongValue()); } @Override - public Char2LongMap.Entry pollFirst() { + public Char2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstLongValue()); pollFirstCharKey(); return entry; } @Override - public Char2LongMap.Entry pollLast() { + public Char2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastLongValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstCharKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Char2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1284,16 +1399,20 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2LongLinkedOpenCustomHashMap extends Char2LongOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ObjectLinkedOpenCustomHashMap.java index cf0f109..2724a94 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom return getDefaultReturnValue(); } + @Override + public V putFirst(char key, V value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 V putLast(char key, V value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -388,6 +436,52 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom return values[lastIndex]; } + @Override + public Char2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> char2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } @Override - public Char2ObjectMap.Entry first() { + public Char2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstCharKey(), firstValue()); } @Override - public Char2ObjectMap.Entry last() { + public Char2ObjectMap.Entry getLast() { return new BasicEntry<>(lastCharKey(), lastValue()); } @Override - public Char2ObjectMap.Entry pollFirst() { + public Char2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstCharKey(), firstValue()); pollFirstCharKey(); return entry; } @Override - public Char2ObjectMap.Entry pollLast() { + public Char2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastCharKey(), lastValue()); pollLastCharKey(); return entry; @@ -613,7 +707,12 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,31 +1129,42 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Char2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Char2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Char2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstCharKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastCharKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Char2ObjectLinkedOpenCustomHashMap extends Char2ObjectOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ShortLinkedOpenCustomHashMap.java index f4e543f..dd6be69 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/customHash/Char2ShortLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.utils.CharStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -258,6 +258,54 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM return getDefaultReturnValue(); } + @Override + public short putFirst(char key, short value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + 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 short putLast(char key, short value) { + if(strategy.equals(key, (char)0)) { + 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], (char)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || strategy.equals(firstCharKey(), key)) return false; @@ -393,6 +441,52 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM return values[lastIndex]; } + @Override + public Char2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getCharKey(), (char)0)) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } @Override - public Char2ShortMap.Entry first() { + public Char2ShortMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstShortValue()); } @Override - public Char2ShortMap.Entry last() { + public Char2ShortMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastShortValue()); } @Override - public Char2ShortMap.Entry pollFirst() { + public Char2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstShortValue()); pollFirstCharKey(); return entry; } @Override - public Char2ShortMap.Entry pollLast() { + public Char2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastShortValue()); pollLastCharKey(); return entry; @@ -618,7 +712,12 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1030,30 +1134,41 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Char2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Char2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstCharKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Char2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Char2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastCharKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1211,7 +1326,7 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1241,7 +1356,7 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1263,7 +1378,7 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1284,16 +1399,20 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Char2ShortLinkedOpenCustomHashMap extends Char2ShortOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2BooleanLinkedOpenHashMap.java index 37cdb47..02a3e93 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2BooleanOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple return getDefaultReturnValue(); } + @Override + public boolean putFirst(char key, boolean value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 boolean putLast(char key, boolean value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple return values[lastIndex]; } + @Override + public Char2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } @Override - public Char2BooleanMap.Entry first() { + public Char2BooleanMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstBooleanValue()); } @Override - public Char2BooleanMap.Entry last() { + public Char2BooleanMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastBooleanValue()); } @Override - public Char2BooleanMap.Entry pollFirst() { + public Char2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstBooleanValue()); pollFirstCharKey(); return entry; } @Override - public Char2BooleanMap.Entry pollLast() { + public Char2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastBooleanValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Char2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstCharKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2BooleanLinkedOpenHashMap extends Char2BooleanOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ByteLinkedOpenHashMap.java index 94f2df4..3a8560e 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ByteLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ByteOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -235,6 +235,54 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements return getDefaultReturnValue(); } + @Override + public byte putFirst(char key, byte value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 byte putLast(char key, byte value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements return values[lastIndex]; } + @Override + public Char2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } @Override - public Char2ByteMap.Entry first() { + public Char2ByteMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstByteValue()); } @Override - public Char2ByteMap.Entry last() { + public Char2ByteMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastByteValue()); } @Override - public Char2ByteMap.Entry pollFirst() { + public Char2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstByteValue()); pollFirstCharKey(); return entry; } @Override - public Char2ByteMap.Entry pollLast() { + public Char2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastByteValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Char2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstCharKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1279,13 +1394,16 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2ByteLinkedOpenHashMap extends Char2ByteOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2CharLinkedOpenHashMap.java index 03b2ae3..cac51a3 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2CharLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2CharOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements return getDefaultReturnValue(); } + @Override + public char putFirst(char key, char value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 char putLast(char key, char value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -384,6 +432,52 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements return values[lastIndex]; } + @Override + public Char2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } @Override - public Char2CharMap.Entry first() { + public Char2CharMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstCharValue()); } @Override - public Char2CharMap.Entry last() { + public Char2CharMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastCharValue()); } @Override - public Char2CharMap.Entry pollFirst() { + public Char2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstCharValue()); pollFirstCharKey(); return entry; } @Override - public Char2CharMap.Entry pollLast() { + public Char2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastCharValue()); pollLastCharKey(); return entry; @@ -609,7 +703,12 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1018,32 +1122,43 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2CharLinkedOpenHashMap.this.clear(); + public void clear() { Char2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstCharKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1200,7 +1315,7 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1230,7 +1345,7 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1252,7 +1367,7 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1272,13 +1387,16 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1309,11 +1427,11 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Char2CharLinkedOpenHashMap extends Char2CharOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2DoubleLinkedOpenHashMap.java index 16ff04e..5efd2bd 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2DoubleLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2DoubleOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -235,6 +235,54 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public double putFirst(char key, double value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 double putLast(char key, double value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme return values[lastIndex]; } + @Override + public Char2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } @Override - public Char2DoubleMap.Entry first() { + public Char2DoubleMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstDoubleValue()); } @Override - public Char2DoubleMap.Entry last() { + public Char2DoubleMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastDoubleValue()); } @Override - public Char2DoubleMap.Entry pollFirst() { + public Char2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstDoubleValue()); pollFirstCharKey(); return entry; } @Override - public Char2DoubleMap.Entry pollLast() { + public Char2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastDoubleValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Char2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstCharKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1279,13 +1394,16 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2DoubleLinkedOpenHashMap extends Char2DoubleOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2FloatLinkedOpenHashMap.java index 156cda0..9310199 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2FloatLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2FloatOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -235,6 +235,54 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement return getDefaultReturnValue(); } + @Override + public float putFirst(char key, float value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 float putLast(char key, float value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement return values[lastIndex]; } + @Override + public Char2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } @Override - public Char2FloatMap.Entry first() { + public Char2FloatMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstFloatValue()); } @Override - public Char2FloatMap.Entry last() { + public Char2FloatMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastFloatValue()); } @Override - public Char2FloatMap.Entry pollFirst() { + public Char2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstFloatValue()); pollFirstCharKey(); return entry; } @Override - public Char2FloatMap.Entry pollLast() { + public Char2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastFloatValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Char2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstCharKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1279,13 +1394,16 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2FloatLinkedOpenHashMap extends Char2FloatOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2IntLinkedOpenHashMap.java index abd2172..6552218 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2IntOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch return getDefaultReturnValue(); } + @Override + public int putFirst(char key, int value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 int putLast(char key, int value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch return values[lastIndex]; } + @Override + public Char2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } @Override - public Char2IntMap.Entry first() { + public Char2IntMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstIntValue()); } @Override - public Char2IntMap.Entry last() { + public Char2IntMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastIntValue()); } @Override - public Char2IntMap.Entry pollFirst() { + public Char2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstIntValue()); pollFirstCharKey(); return entry; } @Override - public Char2IntMap.Entry pollLast() { + public Char2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastIntValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2IntLinkedOpenHashMap.this.clear(); + public void clear() { Char2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstCharKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2IntLinkedOpenHashMap extends Char2IntOpenHashMap implements Ch public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2LongLinkedOpenHashMap.java index 328f7fc..361aef6 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2LongLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2LongOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -235,6 +235,54 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements return getDefaultReturnValue(); } + @Override + public long putFirst(char key, long value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 long putLast(char key, long value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements return values[lastIndex]; } + @Override + public Char2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } @Override - public Char2LongMap.Entry first() { + public Char2LongMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstLongValue()); } @Override - public Char2LongMap.Entry last() { + public Char2LongMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastLongValue()); } @Override - public Char2LongMap.Entry pollFirst() { + public Char2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstLongValue()); pollFirstCharKey(); return entry; } @Override - public Char2LongMap.Entry pollLast() { + public Char2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastLongValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2LongLinkedOpenHashMap.this.clear(); + public void clear() { Char2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstCharKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1279,13 +1394,16 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2LongLinkedOpenHashMap extends Char2LongOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ObjectLinkedOpenHashMap.java index c5a7713..9c3fba1 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ObjectOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i return getDefaultReturnValue(); } + @Override + public V putFirst(char key, V value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 V putLast(char key, V value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -375,6 +423,52 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i return values[lastIndex]; } + @Override + public Char2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> char2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } @Override - public Char2ObjectMap.Entry first() { + public Char2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstCharKey(), firstValue()); } @Override - public Char2ObjectMap.Entry last() { + public Char2ObjectMap.Entry getLast() { return new BasicEntry<>(lastCharKey(), lastValue()); } @Override - public Char2ObjectMap.Entry pollFirst() { + public Char2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstCharKey(), firstValue()); pollFirstCharKey(); return entry; } @Override - public Char2ObjectMap.Entry pollLast() { + public Char2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastCharKey(), lastValue()); pollLastCharKey(); return entry; @@ -600,7 +694,12 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1009,33 +1113,44 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Char2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstCharKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1192,7 +1307,7 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1222,7 +1337,7 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1244,7 +1359,7 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1301,11 +1419,11 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Char2ObjectLinkedOpenHashMap extends Char2ObjectOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ShortLinkedOpenHashMap.java index 97c8b3c..5ddde8b 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/hash/Char2ShortLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ShortOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -235,6 +235,54 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement return getDefaultReturnValue(); } + @Override + public short putFirst(char key, short value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(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 short putLast(char key, short value) { + if(key == (char)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Character.hashCode(key)) & mask; + while(key == (char)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(char key) { if(isEmpty() || firstCharKey() == key) return false; @@ -391,6 +439,52 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement return values[lastIndex]; } + @Override + public Char2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Char2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getCharKey() == (char)0) { + containsNull = false; + keys[nullIndex] = (char)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet char2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } @Override - public Char2ShortMap.Entry first() { + public Char2ShortMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstShortValue()); } @Override - public Char2ShortMap.Entry last() { + public Char2ShortMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastShortValue()); } @Override - public Char2ShortMap.Entry pollFirst() { + public Char2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstShortValue()); pollFirstCharKey(); return entry; } @Override - public Char2ShortMap.Entry pollLast() { + public Char2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastShortValue()); pollLastCharKey(); return entry; @@ -616,7 +710,12 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { + public char removeLastChar() { return pollLastCharKey(); } @@ -1025,32 +1129,43 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Char2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Char2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Char2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstCharKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1207,7 +1322,7 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1237,7 +1352,7 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1259,7 +1374,7 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1279,13 +1394,16 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1316,11 +1434,11 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Char2ShortLinkedOpenHashMap extends Char2ShortOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2BooleanOpenHashMap.java index 5609e59..1f06c0f 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im @Override public boolean putAndMoveToLast(char key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(char key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(char key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im public boolean moveToLast(Char2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2BooleanMap.Entry first() { + public Char2BooleanMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstBooleanValue()); } @Override - public Char2BooleanMap.Entry last() { + public Char2BooleanMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastBooleanValue()); } @Override - public Char2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1211,11 +1250,11 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableChar2BooleanOpenHashMap extends AbstractChar2BooleanMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ByteOpenHashMap.java index 7e2c502..8f04fa8 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ByteOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen @Override public byte putAndMoveToLast(char key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(char key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(char key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2ByteEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen public boolean moveToLast(Char2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2ByteMap.Entry first() { + public Char2ByteMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstByteValue()); } @Override - public Char2ByteMap.Entry last() { + public Char2ByteMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastByteValue()); } @Override - public Char2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2ByteOpenHashMap extends AbstractChar2ByteMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2CharOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2CharOpenHashMap.java index 48e2675..31dd939 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2CharOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.chars.utils.CharArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen @Override public char putAndMoveToLast(char key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(char key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(char key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2CharEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen public boolean moveToLast(Char2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2CharMap.Entry first() { + public Char2CharMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstCharValue()); } @Override - public Char2CharMap.Entry last() { + public Char2CharMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastCharValue()); } @Override - public Char2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1170,13 +1206,16 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1207,11 +1246,11 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableChar2CharOpenHashMap extends AbstractChar2CharMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2DoubleOpenHashMap.java index ac400e2..53c6719 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2DoubleOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl @Override public double putAndMoveToLast(char key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(char key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(char key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2DoubleEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl public boolean moveToLast(Char2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2DoubleMap.Entry first() { + public Char2DoubleMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstDoubleValue()); } @Override - public Char2DoubleMap.Entry last() { + public Char2DoubleMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastDoubleValue()); } @Override - public Char2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2DoubleOpenHashMap extends AbstractChar2DoubleMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2FloatOpenHashMap.java index 33af531..70d04f6 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2FloatOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem @Override public float putAndMoveToLast(char key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(char key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(char key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2FloatEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem public boolean moveToLast(Char2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2FloatMap.Entry first() { + public Char2FloatMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstFloatValue()); } @Override - public Char2FloatMap.Entry last() { + public Char2FloatMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastFloatValue()); } @Override - public Char2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2FloatOpenHashMap extends AbstractChar2FloatMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2IntOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2IntOpenHashMap.java index 5376a77..869c7e9 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements @Override public int putAndMoveToLast(char key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(char key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(char key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements public boolean moveToLast(Char2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2IntMap.Entry first() { + public Char2IntMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstIntValue()); } @Override - public Char2IntMap.Entry last() { + public Char2IntMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastIntValue()); } @Override - public Char2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2IntOpenHashMap extends AbstractChar2IntMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2LongOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2LongOpenHashMap.java index 7305294..33c0aee 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2LongOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen @Override public long putAndMoveToLast(char key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(char key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(char key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2LongEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen public boolean moveToLast(Char2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2LongMap.Entry first() { + public Char2LongMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstLongValue()); } @Override - public Char2LongMap.Entry last() { + public Char2LongMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastLongValue()); } @Override - public Char2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2LongOpenHashMap extends AbstractChar2LongMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ObjectOpenHashMap.java index fb2ea5a..301fd39 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> char2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap o) { throw new UnsupportedOperationException(); } @Override - public Char2ObjectMap.Entry first() { + public Char2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstCharKey(), firstValue()); } @Override - public Char2ObjectMap.Entry last() { + public Char2ObjectMap.Entry getLast() { return new BasicEntry<>(lastCharKey(), lastValue()); } @Override - public Char2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableChar2ObjectOpenHashMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap extends AbstractChar2ObjectMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ShortOpenHashMap.java index 8cd06ff..384e775 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/immutable/ImmutableChar2ShortOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem /** KeySet cache */ protected transient CharOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem @Override public short putAndMoveToLast(char key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(char key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(char key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Char2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Char2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Char2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet char2ShortEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem public boolean moveToLast(Char2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Char2ShortMap.Entry first() { + public Char2ShortMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstShortValue()); } @Override - public Char2ShortMap.Entry last() { + public Char2ShortMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastShortValue()); } @Override - public Char2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem @Override public CharListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public char firstChar() { + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableChar2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableChar2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(char from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(char from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(char from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1179,13 +1215,16 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(char from) { @@ -1216,11 +1255,11 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableChar2ShortOpenHashMap extends AbstractChar2ShortMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2BooleanArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2BooleanArrayMap.java index b31f12c..4495a6c 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2BooleanOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha return lastValue; } + @Override + public boolean putFirst(char key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(char key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha return result; } + @Override + public Char2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(char key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } @Override - public Char2BooleanMap.Entry first() { + public Char2BooleanMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstBooleanValue()); } @Override - public Char2BooleanMap.Entry last() { + public Char2BooleanMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastBooleanValue()); } @Override - public Char2BooleanMap.Entry pollFirst() { + public Char2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstBooleanValue()); pollFirstCharKey(); return entry; } @Override - public Char2BooleanMap.Entry pollLast() { + public Char2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastBooleanValue()); pollLastCharKey(); return entry; @@ -720,7 +769,12 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha @Override public boolean moveToLast(char o) { return Char2BooleanArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha @Override public void clear() { Char2BooleanArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2BooleanArrayMap.this.size(); - } - + public int size() { return Char2BooleanArrayMap.this.size(); } @Override - public void clear() { - Char2BooleanArrayMap.this.clear(); + public void clear() { Char2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstCharKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1233,6 +1292,9 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Char2BooleanArrayMap extends AbstractChar2BooleanMap implements Cha public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ByteArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ByteArrayMap.java index 88731b8..95b24ed 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ByteArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ByteOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -63,7 +63,7 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte return lastValue; } + @Override + public byte putFirst(char key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(char key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte return result; } + @Override + public Char2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } @Override - public Char2ByteMap.Entry first() { + public Char2ByteMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstByteValue()); } @Override - public Char2ByteMap.Entry last() { + public Char2ByteMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastByteValue()); } @Override - public Char2ByteMap.Entry pollFirst() { + public Char2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstByteValue()); pollFirstCharKey(); return entry; } @Override - public Char2ByteMap.Entry pollLast() { + public Char2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastByteValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte @Override public boolean moveToLast(char o) { return Char2ByteArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte @Override public void clear() { Char2ByteArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ByteArrayMap.this.size(); - } - + public int size() { return Char2ByteArrayMap.this.size(); } @Override - public void clear() { - Char2ByteArrayMap.this.clear(); + public void clear() { Char2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstCharKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2ByteMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2ByteMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2ByteArrayMap extends AbstractChar2ByteMap implements Char2Byte public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2CharArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2CharArrayMap.java index 67daf62..f44a57e 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2CharArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2CharOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char return lastValue; } + @Override + public char putFirst(char key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(char key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char return result; } + @Override + public Char2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(char key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } @Override - public Char2CharMap.Entry first() { + public Char2CharMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstCharValue()); } @Override - public Char2CharMap.Entry last() { + public Char2CharMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastCharValue()); } @Override - public Char2CharMap.Entry pollFirst() { + public Char2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstCharValue()); pollFirstCharKey(); return entry; } @Override - public Char2CharMap.Entry pollLast() { + public Char2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastCharValue()); pollLastCharKey(); return entry; @@ -736,7 +785,12 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char @Override public boolean moveToLast(char o) { return Char2CharArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char @Override public void clear() { Char2CharArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2CharArrayMap.this.size(); - } - + public int size() { return Char2CharArrayMap.this.size(); } @Override - public void clear() { - Char2CharArrayMap.this.clear(); + public void clear() { Char2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstCharKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2CharMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2CharMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1249,6 +1308,9 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Char2CharArrayMap extends AbstractChar2CharMap implements Char2Char public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2DoubleArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2DoubleArrayMap.java index 0b828e9..29c1758 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2DoubleArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2DoubleOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -63,7 +63,7 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 return lastValue; } + @Override + public double putFirst(char key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(char key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 return result; } + @Override + public Char2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } @Override - public Char2DoubleMap.Entry first() { + public Char2DoubleMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstDoubleValue()); } @Override - public Char2DoubleMap.Entry last() { + public Char2DoubleMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastDoubleValue()); } @Override - public Char2DoubleMap.Entry pollFirst() { + public Char2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstDoubleValue()); pollFirstCharKey(); return entry; } @Override - public Char2DoubleMap.Entry pollLast() { + public Char2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastDoubleValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 @Override public boolean moveToLast(char o) { return Char2DoubleArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 @Override public void clear() { Char2DoubleArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2DoubleArrayMap.this.size(); - } - + public int size() { return Char2DoubleArrayMap.this.size(); } @Override - public void clear() { - Char2DoubleArrayMap.this.clear(); + public void clear() { Char2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstCharKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2DoubleMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2DoubleMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2DoubleArrayMap extends AbstractChar2DoubleMap implements Char2 public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2FloatArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2FloatArrayMap.java index 5fab710..9fd238d 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2FloatArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2FloatOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -63,7 +63,7 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl return lastValue; } + @Override + public float putFirst(char key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(char key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl return result; } + @Override + public Char2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } @Override - public Char2FloatMap.Entry first() { + public Char2FloatMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstFloatValue()); } @Override - public Char2FloatMap.Entry last() { + public Char2FloatMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastFloatValue()); } @Override - public Char2FloatMap.Entry pollFirst() { + public Char2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstFloatValue()); pollFirstCharKey(); return entry; } @Override - public Char2FloatMap.Entry pollLast() { + public Char2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastFloatValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl @Override public boolean moveToLast(char o) { return Char2FloatArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl @Override public void clear() { Char2FloatArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2FloatArrayMap.this.size(); - } - + public int size() { return Char2FloatArrayMap.this.size(); } @Override - public void clear() { - Char2FloatArrayMap.this.clear(); + public void clear() { Char2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstCharKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2FloatMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2FloatMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2FloatArrayMap extends AbstractChar2FloatMap implements Char2Fl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2IntArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2IntArrayMap.java index 21a8805..63b1a61 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2IntOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd return lastValue; } + @Override + public int putFirst(char key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(char key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd return result; } + @Override + public Char2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } @Override - public Char2IntMap.Entry first() { + public Char2IntMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstIntValue()); } @Override - public Char2IntMap.Entry last() { + public Char2IntMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastIntValue()); } @Override - public Char2IntMap.Entry pollFirst() { + public Char2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstIntValue()); pollFirstCharKey(); return entry; } @Override - public Char2IntMap.Entry pollLast() { + public Char2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastIntValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd @Override public boolean moveToLast(char o) { return Char2IntArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd @Override public void clear() { Char2IntArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2IntArrayMap.this.size(); - } - + public int size() { return Char2IntArrayMap.this.size(); } @Override - public void clear() { - Char2IntArrayMap.this.clear(); + public void clear() { Char2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstCharKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2IntArrayMap extends AbstractChar2IntMap implements Char2IntOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2LongArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2LongArrayMap.java index a42f724..ee76cac 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2LongArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2LongOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -63,7 +63,7 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long return lastValue; } + @Override + public long putFirst(char key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(char key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long return result; } + @Override + public Char2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } @Override - public Char2LongMap.Entry first() { + public Char2LongMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstLongValue()); } @Override - public Char2LongMap.Entry last() { + public Char2LongMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastLongValue()); } @Override - public Char2LongMap.Entry pollFirst() { + public Char2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstLongValue()); pollFirstCharKey(); return entry; } @Override - public Char2LongMap.Entry pollLast() { + public Char2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastLongValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long @Override public boolean moveToLast(char o) { return Char2LongArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long @Override public void clear() { Char2LongArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2LongArrayMap.this.size(); - } - + public int size() { return Char2LongArrayMap.this.size(); } @Override - public void clear() { - Char2LongArrayMap.this.clear(); + public void clear() { Char2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstCharKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2LongMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2LongMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2LongArrayMap extends AbstractChar2LongMap implements Char2Long public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ObjectArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ObjectArrayMap.java index 82ec8a9..c831e34 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ObjectOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements return lastValue; } + @Override + public V putFirst(char key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(char key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements return result; } + @Override + public Char2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Char2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Char2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(char key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } @Override - public Char2ObjectMap.Entry first() { + public Char2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstCharKey(), firstValue()); } @Override - public Char2ObjectMap.Entry last() { + public Char2ObjectMap.Entry getLast() { return new BasicEntry<>(lastCharKey(), lastValue()); } @Override - public Char2ObjectMap.Entry pollFirst() { + public Char2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstCharKey(), firstValue()); pollFirstCharKey(); return entry; } @Override - public Char2ObjectMap.Entry pollLast() { + public Char2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastCharKey(), lastValue()); pollLastCharKey(); return entry; @@ -656,7 +705,12 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements @Override public boolean moveToLast(char o) { return Char2ObjectArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements @Override public void clear() { Char2ObjectArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ObjectArrayMap.this.size(); - } - + public int size() { return Char2ObjectArrayMap.this.size(); } @Override - public void clear() { - Char2ObjectArrayMap.this.clear(); + public void clear() { Char2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstCharKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1169,6 +1228,9 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Char2ObjectArrayMap extends AbstractChar2ObjectMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ShortArrayMap.java b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ShortArrayMap.java index 8278650..3c38e62 100644 --- a/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/impl/misc/Char2ShortArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.chars.maps.interfaces.Char2ShortOrderedMap; import speiger.src.collections.chars.sets.AbstractCharSet; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -63,7 +63,7 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh /** KeySet cache */ protected CharOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh return lastValue; } + @Override + public short putFirst(char key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(char key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(char key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh return result; } + @Override + public Char2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Char2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Char2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Char2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(char key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } @Override - public Char2ShortMap.Entry first() { + public Char2ShortMap.Entry getFirst() { return new BasicEntry(firstCharKey(), firstShortValue()); } @Override - public Char2ShortMap.Entry last() { + public Char2ShortMap.Entry getLast() { return new BasicEntry(lastCharKey(), lastShortValue()); } @Override - public Char2ShortMap.Entry pollFirst() { + public Char2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstCharKey(), firstShortValue()); pollFirstCharKey(); return entry; } @Override - public Char2ShortMap.Entry pollLast() { + public Char2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastCharKey(), lastShortValue()); pollLastCharKey(); return entry; @@ -743,7 +792,12 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh @Override public boolean moveToLast(char o) { return Char2ShortArrayMap.this.moveToLast(o); } @Override - public CharListIterator iterator() { return new KeyIterator(); } + public CharListIterator iterator() { return new KeyIterator(true); } + @Override + public CharListIterator reverseIterator() { return new KeyIterator(false); } @Override public CharBidirectionalIterator iterator(char fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh @Override public void clear() { Char2ShortArrayMap.this.clear(); } @Override - public char firstChar() { return firstCharKey(); } + public char getFirstChar() { return firstCharKey(); } @Override - public char pollFirstChar() { return pollFirstCharKey(); } + public char removeFirstChar() { return pollFirstCharKey(); } @Override - public char lastChar() { return lastCharKey(); } + public char getLastChar() { return lastCharKey(); } @Override - public char pollLastChar() { return pollLastCharKey(); } + public char removeLastChar() { return pollLastCharKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Char2ShortArrayMap.this.size(); - } - + public int size() { return Char2ShortArrayMap.this.size(); } @Override - public void clear() { - Char2ShortArrayMap.this.clear(); + public void clear() { Char2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstCharKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastCharKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(char from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(char element) { super(element); } @Override public Char2ShortMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(char from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(char element) { super(element); } @Override public Char2ShortMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } private class KeyIterator extends MapIterator implements CharListIterator { - public KeyIterator() {} - public KeyIterator(char element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(char element) { super(element); } @Override public char previousChar() { @@ -1256,6 +1315,9 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(char element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(char element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Char2ShortArrayMap extends AbstractChar2ShortMap implements Char2Sh public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanMap.java index 6c89a5c..edf0f9d 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanMap.java @@ -94,7 +94,7 @@ public interface Char2BooleanMap extends Map, CharPredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanOrderedMap.java index 4307ec7..ea21e1d 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2BooleanMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2BooleanOrderedMap extends Char2BooleanMap */ public boolean putAndMoveToLast(char key, boolean 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 boolean putFirst(char key, boolean 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 boolean putLast(char key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2BooleanOrderedMap extends Char2BooleanMap */ public boolean lastBooleanValue(); + + public Char2BooleanMap.Entry firstEntry(); + + public Char2BooleanMap.Entry lastEntry(); + + public Char2BooleanMap.Entry pollFirstEntry(); + + public Char2BooleanMap.Entry pollLastEntry(); @Override public Char2BooleanOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet char2BooleanEntrySet(); + public default Char2BooleanOrderedMap reversed() { return new AbstractChar2BooleanMap.ReversedChar2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteMap.java index 8ca7198..cd6bc07 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteMap.java @@ -94,7 +94,7 @@ public interface Char2ByteMap extends Map, Char2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteOrderedMap.java index 8abb902..71ce91d 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2ByteMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2ByteOrderedMap extends Char2ByteMap */ public byte putAndMoveToLast(char key, byte 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 byte putFirst(char key, byte 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 byte putLast(char key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2ByteOrderedMap extends Char2ByteMap */ public byte lastByteValue(); + + public Char2ByteMap.Entry firstEntry(); + + public Char2ByteMap.Entry lastEntry(); + + public Char2ByteMap.Entry pollFirstEntry(); + + public Char2ByteMap.Entry pollLastEntry(); @Override public Char2ByteOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet char2ByteEntrySet(); + public default Char2ByteOrderedMap reversed() { return new AbstractChar2ByteMap.ReversedChar2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharMap.java index 91294f6..5178648 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharMap.java @@ -93,7 +93,7 @@ public interface Char2CharMap extends Map, CharUnaryOperat * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharOrderedMap.java index 179b900..7d1b469 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2CharMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2CharOrderedMap extends Char2CharMap */ public char putAndMoveToLast(char key, char 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 char putFirst(char key, char 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 char putLast(char key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2CharOrderedMap extends Char2CharMap */ public char lastCharValue(); + + public Char2CharMap.Entry firstEntry(); + + public Char2CharMap.Entry lastEntry(); + + public Char2CharMap.Entry pollFirstEntry(); + + public Char2CharMap.Entry pollLastEntry(); @Override public Char2CharOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet char2CharEntrySet(); + public default Char2CharOrderedMap reversed() { return new AbstractChar2CharMap.ReversedChar2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleMap.java index 9e748a7..5bd4238 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleMap.java @@ -94,7 +94,7 @@ public interface Char2DoubleMap extends Map, Char2DoubleFunct * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleOrderedMap.java index 9b6dd01..d567171 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2DoubleMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2DoubleOrderedMap extends Char2DoubleMap */ public double putAndMoveToLast(char key, double 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 double putFirst(char key, double 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 double putLast(char key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2DoubleOrderedMap extends Char2DoubleMap */ public double lastDoubleValue(); + + public Char2DoubleMap.Entry firstEntry(); + + public Char2DoubleMap.Entry lastEntry(); + + public Char2DoubleMap.Entry pollFirstEntry(); + + public Char2DoubleMap.Entry pollLastEntry(); @Override public Char2DoubleOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet char2DoubleEntrySet(); + public default Char2DoubleOrderedMap reversed() { return new AbstractChar2DoubleMap.ReversedChar2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatMap.java index 51e1922..cdbecbf 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatMap.java @@ -94,7 +94,7 @@ public interface Char2FloatMap extends Map, Char2FloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatOrderedMap.java index e8a5443..f2defa6 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2FloatMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2FloatOrderedMap extends Char2FloatMap */ public float putAndMoveToLast(char key, float 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 float putFirst(char key, float 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 float putLast(char key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2FloatOrderedMap extends Char2FloatMap */ public float lastFloatValue(); + + public Char2FloatMap.Entry firstEntry(); + + public Char2FloatMap.Entry lastEntry(); + + public Char2FloatMap.Entry pollFirstEntry(); + + public Char2FloatMap.Entry pollLastEntry(); @Override public Char2FloatOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet char2FloatEntrySet(); + public default Char2FloatOrderedMap reversed() { return new AbstractChar2FloatMap.ReversedChar2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntMap.java index 11f4f8e..9fb25a6 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntMap.java @@ -94,7 +94,7 @@ public interface Char2IntMap extends Map, Char2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntOrderedMap.java index 5723db9..113e5eb 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2IntMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2IntOrderedMap extends Char2IntMap */ public int putAndMoveToLast(char key, int 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 int putFirst(char key, int 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 int putLast(char key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2IntOrderedMap extends Char2IntMap */ public int lastIntValue(); + + public Char2IntMap.Entry firstEntry(); + + public Char2IntMap.Entry lastEntry(); + + public Char2IntMap.Entry pollFirstEntry(); + + public Char2IntMap.Entry pollLastEntry(); @Override public Char2IntOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet char2IntEntrySet(); + public default Char2IntOrderedMap reversed() { return new AbstractChar2IntMap.ReversedChar2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongMap.java index 597a9f1..b130cbb 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongMap.java @@ -94,7 +94,7 @@ public interface Char2LongMap extends Map, Char2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongOrderedMap.java index c0f4f63..6de63ce 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2LongMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2LongOrderedMap extends Char2LongMap */ public long putAndMoveToLast(char key, long 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 long putFirst(char key, long 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 long putLast(char key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2LongOrderedMap extends Char2LongMap */ public long lastLongValue(); + + public Char2LongMap.Entry firstEntry(); + + public Char2LongMap.Entry lastEntry(); + + public Char2LongMap.Entry pollFirstEntry(); + + public Char2LongMap.Entry pollLastEntry(); @Override public Char2LongOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet char2LongEntrySet(); + public default Char2LongOrderedMap reversed() { return new AbstractChar2LongMap.ReversedChar2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectMap.java index 6f8ad97..0a60c23 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectMap.java @@ -95,7 +95,7 @@ public interface Char2ObjectMap extends Map, CharFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectOrderedMap.java index 285372c..97e8cbf 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2ObjectMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Char2ObjectOrderedMap extends Char2ObjectMap */ public V putAndMoveToLast(char key, V 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 V putFirst(char key, V 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 V putLast(char key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Char2ObjectOrderedMap extends Char2ObjectMap */ public V lastValue(); + + public Char2ObjectMap.Entry firstEntry(); + + public Char2ObjectMap.Entry lastEntry(); + + public Char2ObjectMap.Entry pollFirstEntry(); + + public Char2ObjectMap.Entry pollLastEntry(); @Override public Char2ObjectOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> char2ObjectEntrySet(); + public default Char2ObjectOrderedMap reversed() { return new AbstractChar2ObjectMap.ReversedChar2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortMap.java index 36cf1c0..6d40ab3 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortMap.java @@ -94,7 +94,7 @@ public interface Char2ShortMap extends Map, Char2ShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().charValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortOrderedMap.java b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortOrderedMap.java index 38e28b9..b682e43 100644 --- a/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/chars/maps/interfaces/Char2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.chars.maps.interfaces; import speiger.src.collections.chars.utils.maps.Char2ShortMaps; +import speiger.src.collections.chars.maps.abstracts.AbstractChar2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Char2ShortOrderedMap extends Char2ShortMap */ public short putAndMoveToLast(char key, short 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 short putFirst(char key, short 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 short putLast(char key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Char2ShortOrderedMap extends Char2ShortMap */ public short lastShortValue(); + + public Char2ShortMap.Entry firstEntry(); + + public Char2ShortMap.Entry lastEntry(); + + public Char2ShortMap.Entry pollFirstEntry(); + + public Char2ShortMap.Entry pollLastEntry(); @Override public Char2ShortOrderedMap copy(); @Override public CharOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet char2ShortEntrySet(); + public default Char2ShortOrderedMap reversed() { return new AbstractChar2ShortMap.ReversedChar2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/sets/AbstractCharSet.java b/src/main/java/speiger/src/collections/chars/sets/AbstractCharSet.java index cbcb156..029bb49 100644 --- a/src/main/java/speiger/src/collections/chars/sets/AbstractCharSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/AbstractCharSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.chars.sets; import java.util.Set; import speiger.src.collections.chars.collections.AbstractCharCollection; +import speiger.src.collections.chars.collections.CharBidirectionalIterator; import speiger.src.collections.chars.collections.CharIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractCharSet extends AbstractCharCollection implements return false; } } + + public static class ReversedCharOrderedSet extends AbstractCharSet implements CharOrderedSet { + protected CharOrderedSet set; + + public ReversedCharOrderedSet(CharOrderedSet set) { + this.set = set; + } + + @Override + public ReversedCharOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public CharBidirectionalIterator iterator(char fromElement) { + return set.iterator(fromElement); + } + + @Override + public CharBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public CharBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(char o) { + return set.remove(o); + } + + @Override + public boolean add(char o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(char o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(char o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(char o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(char o) { + return set.moveToFirst(o); + } + + @Override + public char getFirstChar() { + return set.getLastChar(); + } + + @Override + public char removeFirstChar() { + return set.removeLastChar(); + } + + @Override + public char getLastChar() { + return set.getFirstChar(); + } + + @Override + public char removeLastChar() { + return set.removeFirstChar(); + } + + @Override + public CharOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/chars/sets/CharArraySet.java b/src/main/java/speiger/src/collections/chars/sets/CharArraySet.java index 353a7ff..c4f5c92 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharArraySet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharArraySet.java @@ -186,13 +186,13 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet } @Override - public char firstChar() { + public char getFirstChar() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public char lastChar() { + public char getLastChar() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -283,7 +283,7 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet } @Override - public char pollFirstChar() { + public char removeFirstChar() { if(size == 0) throw new NoSuchElementException(); char result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -291,7 +291,7 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet } @Override - public char pollLastChar() { + public char removeLastChar() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -414,13 +414,18 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet @Override public CharBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public CharBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public CharBidirectionalIterator iterator(char fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -471,45 +476,57 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet } private class SetIterator implements CharListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public char nextChar() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public char previousChar() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -529,15 +546,23 @@ public class CharArraySet extends AbstractCharSet implements CharOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenCustomHashSet.java index c19ba24..961efc1 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public boolean moveToFirst(char o) { - if(isEmpty() || strategy.equals(firstChar(), o)) return false; + if(isEmpty() || strategy.equals(getFirstChar(), o)) return false; if(strategy.equals(o, (char)0)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public boolean moveToLast(char o) { - if(isEmpty() || strategy.equals(lastChar(), o)) return false; + if(isEmpty() || strategy.equals(getLastChar(), o)) return false; if(strategy.equals(o, (char)0)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement } @Override - public char firstChar() { + public char getFirstChar() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public char pollFirstChar() { + public char removeFirstChar() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement } @Override - public char lastChar() { + public char getLastChar() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public char pollLastChar() { + public char removeLastChar() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public CharListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement } private class SetIterator implements CharListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(char from) { + this.forward = true; if(strategy.equals(from, (char)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public char previousChar() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class CharLinkedOpenCustomHashSet extends CharOpenCustomHashSet implement @Override public char nextChar() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenHashSet.java index 39d1819..327a90d 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public boolean moveToFirst(char o) { - if(isEmpty() || firstChar() == o) return false; + if(isEmpty() || getFirstChar() == o) return false; if(o == (char)0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public boolean moveToLast(char o) { - if(isEmpty() || lastChar() == o) return false; + if(isEmpty() || getLastChar() == o) return false; if(o == (char)0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere } @Override - public char firstChar() { + public char getFirstChar() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public char pollFirstChar() { + public char removeFirstChar() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere } @Override - public char lastChar() { + public char getLastChar() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public char pollLastChar() { + public char removeLastChar() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public CharListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere } private class SetIterator implements CharListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(char from) { + this.forward = true; if(from == (char)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public char previousChar() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class CharLinkedOpenHashSet extends CharOpenHashSet implements CharOrdere @Override public char nextChar() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/chars/sets/CharNavigableSet.java b/src/main/java/speiger/src/collections/chars/sets/CharNavigableSet.java index f2bbcd3..a73b57d 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharNavigableSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.chars.collections.CharBidirectionalIterator; import speiger.src.collections.chars.collections.CharSplititerator; -import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.chars.utils.CharSplititerators; +import speiger.src.collections.chars.utils.CharSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/chars/sets/CharOrderedSet.java b/src/main/java/speiger/src/collections/chars/sets/CharOrderedSet.java index ec8b892..3c49f85 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharOrderedSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.chars.sets; import speiger.src.collections.chars.collections.CharBidirectionalIterator; import speiger.src.collections.chars.collections.CharSplititerator; -import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.chars.utils.CharSplititerators; +import speiger.src.collections.chars.sets.AbstractCharSet.ReversedCharOrderedSet; +import speiger.src.collections.chars.utils.CharSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface CharOrderedSet extends CharSet @Override public CharBidirectionalIterator iterator(); + public CharBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface CharOrderedSet extends CharSet * A method to get the first element in the set * @return first element in the set */ - public char firstChar(); + public char getFirstChar(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public char pollFirstChar(); + public char removeFirstChar(); /** * A method to get the last element in the set * @return last element in the set */ - public char lastChar(); + public char getLastChar(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public char pollLastChar(); + public char removeLastChar(); + + public default CharOrderedSet reversed() { return new ReversedCharOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/chars/sets/CharSet.java b/src/main/java/speiger/src/collections/chars/sets/CharSet.java index 7be9724..c8bdbd7 100644 --- a/src/main/java/speiger/src/collections/chars/sets/CharSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/CharSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.chars.collections.CharCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.collections.CharSplititerator; -import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.chars.utils.CharSplititerators; +import speiger.src.collections.chars.utils.CharSets; /** diff --git a/src/main/java/speiger/src/collections/chars/sets/ImmutableCharOpenHashSet.java b/src/main/java/speiger/src/collections/chars/sets/ImmutableCharOpenHashSet.java index 9776b33..6fdfaf7 100644 --- a/src/main/java/speiger/src/collections/chars/sets/ImmutableCharOpenHashSet.java +++ b/src/main/java/speiger/src/collections/chars/sets/ImmutableCharOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd } @Override - public char firstChar() { + public char getFirstChar() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { + public char getLastChar() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd @Override public CharListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public CharListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd } private class SetIterator implements CharListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(char from) { + this.forward = true; if(from == (char)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd @Override public char previousChar() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableCharOpenHashSet extends AbstractCharSet implements CharOrd @Override public char nextChar() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/chars/utils/CharCollections.java b/src/main/java/speiger/src/collections/chars/utils/CharCollections.java index 2e2019b..8120ff0 100644 --- a/src/main/java/speiger/src/collections/chars/utils/CharCollections.java +++ b/src/main/java/speiger/src/collections/chars/utils/CharCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.chars.collections.AbstractCharCollection; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -51,6 +52,34 @@ public class CharCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static CharOrderedCollection unmodifiable(CharOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static CharOrderedCollection synchronize(CharOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static CharOrderedCollection synchronize(CharOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -584,6 +613,37 @@ public class CharCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements CharOrderedCollection { + CharOrderedCollection c; + + SynchronizedOrderedCollection(CharOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(CharOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public CharOrderedCollection reversed() { return CharCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(char e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(char e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public char getFirstChar() { synchronized(mutex) { return this.c.getFirstChar(); } } + @Override + public char removeFirstChar() { synchronized(mutex) { return this.c.removeFirstChar(); } } + @Override + public char getLastChar() { synchronized(mutex) { return this.c.getLastChar(); } } + @Override + public char removeLastChar() { synchronized(mutex) { return this.c.removeLastChar(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -705,6 +765,33 @@ public class CharCollections public int count(CharPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements CharOrderedCollection { + CharOrderedCollection c; + + UnmodifiableOrderedCollection(CharOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public CharOrderedCollection reversed() { return CharCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return c.getFirstChar(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return c.getLastChar(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/chars/utils/CharIterators.java b/src/main/java/speiger/src/collections/chars/utils/CharIterators.java index 9b4210a..7863f37 100644 --- a/src/main/java/speiger/src/collections/chars/utils/CharIterators.java +++ b/src/main/java/speiger/src/collections/chars/utils/CharIterators.java @@ -34,7 +34,7 @@ public class CharIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static CharListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class CharIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(char... a) { + public static CharIterator wrap(char... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class CharIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(char[] a, int start, int end) { + public static CharIterator wrap(char[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/chars/utils/CharLists.java b/src/main/java/speiger/src/collections/chars/utils/CharLists.java index f83a514..eb2e1e2 100644 --- a/src/main/java/speiger/src/collections/chars/utils/CharLists.java +++ b/src/main/java/speiger/src/collections/chars/utils/CharLists.java @@ -30,7 +30,7 @@ public class CharLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static CharList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/chars/utils/CharSets.java b/src/main/java/speiger/src/collections/chars/utils/CharSets.java index 0b05bba..051468f 100644 --- a/src/main/java/speiger/src/collections/chars/utils/CharSets.java +++ b/src/main/java/speiger/src/collections/chars/utils/CharSets.java @@ -312,17 +312,19 @@ public class CharSets @Override public CharBidirectionalIterator iterator() { return CharIterators.unmodifiable(s.iterator()); } @Override + public CharBidirectionalIterator reverseIterator() { return CharIterators.unmodifiable(s.reverseIterator()); } + @Override public CharBidirectionalIterator iterator(char fromElement) { return CharIterators.unmodifiable(s.iterator(fromElement)); } @Override public CharOrderedSet copy() { return s.copy(); } @Override - public char firstChar() { return s.firstChar(); } + public char getFirstChar() { return s.getFirstChar(); } @Override - public char pollFirstChar() { throw new UnsupportedOperationException(); } + public char removeFirstChar() { throw new UnsupportedOperationException(); } @Override - public char lastChar() { return s.lastChar(); } + public char getLastChar() { return s.getLastChar(); } @Override - public char pollLastChar() { throw new UnsupportedOperationException(); } + public char removeLastChar() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements CharSortedSet @@ -583,17 +585,19 @@ public class CharSets @Override public CharBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public CharBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public CharBidirectionalIterator iterator(char fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public CharOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public char firstChar() { synchronized(mutex) { return s.firstChar(); } } + public char getFirstChar() { synchronized(mutex) { return s.getFirstChar(); } } @Override - public char pollFirstChar() { synchronized(mutex) { return s.pollFirstChar(); } } + public char removeFirstChar() { synchronized(mutex) { return s.removeFirstChar(); } } @Override - public char lastChar() { synchronized(mutex) { return s.lastChar(); } } + public char getLastChar() { synchronized(mutex) { return s.getLastChar(); } } @Override - public char pollLastChar() { synchronized(mutex) { return s.pollLastChar(); } } + public char removeLastChar() { synchronized(mutex) { return s.removeLastChar(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2BooleanMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2BooleanMaps.java index fb7b871..2bcd743 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Char2BooleanMaps @Override public boolean putAndMoveToLast(char key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(char key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(char key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Char2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Char2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2BooleanOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet char2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Char2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2BooleanMap.Entry first() { return set.first(); } + public Char2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2BooleanMap.Entry last() { return set.last(); } + public Char2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Char2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Char2BooleanMaps @Override public boolean putAndMoveToLast(char key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(char key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(char key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Char2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Char2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet char2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ByteMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ByteMaps.java index df14315..87bbac9 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ByteMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Char2ByteMaps @Override public byte putAndMoveToLast(char key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(char key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(char key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Char2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2ByteOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet char2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Char2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2ByteMap.Entry first() { return set.first(); } + public Char2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ByteMap.Entry last() { return set.last(); } + public Char2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Char2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2ByteMaps @Override public byte putAndMoveToLast(char key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(char key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(char key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Char2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet char2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2CharMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2CharMaps.java index 33ae0c7..93171c0 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2CharMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -438,6 +439,10 @@ public class Char2CharMaps @Override public char putAndMoveToLast(char key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(char key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(char key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Char2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Char2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2CharOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet char2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2CharEntrySet()); @@ -616,15 +633,17 @@ public class Char2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2CharMap.Entry first() { return set.first(); } + public Char2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2CharMap.Entry last() { return set.last(); } + public Char2CharMap.Entry getLast() { return set.getLast(); } @Override - public Char2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Char2CharMaps @Override public char putAndMoveToLast(char key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(char key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(char key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Char2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Char2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet char2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2DoubleMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2DoubleMaps.java index 89eac95..4d1dc69 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Char2DoubleMaps @Override public double putAndMoveToLast(char key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(char key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(char key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Char2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2DoubleOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet char2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Char2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2DoubleMap.Entry first() { return set.first(); } + public Char2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2DoubleMap.Entry last() { return set.last(); } + public Char2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Char2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2DoubleMaps @Override public double putAndMoveToLast(char key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(char key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(char key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Char2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet char2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2FloatMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2FloatMaps.java index 87cbee7..51cd505 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2FloatMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Char2FloatMaps @Override public float putAndMoveToLast(char key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(char key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(char key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Char2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2FloatOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet char2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Char2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2FloatMap.Entry first() { return set.first(); } + public Char2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2FloatMap.Entry last() { return set.last(); } + public Char2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Char2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2FloatMaps @Override public float putAndMoveToLast(char key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(char key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(char key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Char2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet char2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2IntMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2IntMaps.java index 1ce34c3..bf8ef5d 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2IntMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Char2IntMaps @Override public int putAndMoveToLast(char key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(char key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(char key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Char2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2IntOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet char2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2IntEntrySet()); @@ -617,15 +634,17 @@ public class Char2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2IntMap.Entry first() { return set.first(); } + public Char2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2IntMap.Entry last() { return set.last(); } + public Char2IntMap.Entry getLast() { return set.getLast(); } @Override - public Char2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2IntMaps @Override public int putAndMoveToLast(char key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(char key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(char key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Char2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet char2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2LongMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2LongMaps.java index 9c4be5b..bbc0665 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2LongMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Char2LongMaps @Override public long putAndMoveToLast(char key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(char key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(char key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Char2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2LongOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet char2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2LongEntrySet()); @@ -617,15 +634,17 @@ public class Char2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2LongMap.Entry first() { return set.first(); } + public Char2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2LongMap.Entry last() { return set.last(); } + public Char2LongMap.Entry getLast() { return set.getLast(); } @Override - public Char2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2LongMaps @Override public long putAndMoveToLast(char key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(char key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(char key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Char2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet char2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ObjectMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ObjectMaps.java index fc30692..0067efc 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Char2ObjectMaps @Override public V putAndMoveToLast(char key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(char key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(char key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Char2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2ObjectOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> char2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.char2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Char2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Char2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2ObjectMap.Entry first() { return set.first(); } + public Char2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ObjectMap.Entry last() { return set.last(); } + public Char2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Char2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Char2ObjectMaps @Override public V putAndMoveToLast(char key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(char key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(char key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Char2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Char2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> char2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ShortMaps.java b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ShortMaps.java index ef65cc8..49569cf 100644 --- a/src/main/java/speiger/src/collections/chars/utils/maps/Char2ShortMaps.java +++ b/src/main/java/speiger/src/collections/chars/utils/maps/Char2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.chars.sets.CharOrderedSet; import speiger.src.collections.chars.sets.CharSet; import speiger.src.collections.chars.utils.CharSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Char2ShortMaps @Override public short putAndMoveToLast(char key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(char key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(char key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(char key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(char key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Char2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Char2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Char2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Char2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Char2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Char2ShortOrderedMap copy() { return map.copy(); } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.unmodifiable(map.keySet()); return (CharOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet char2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.char2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Char2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Char2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Char2ShortMap.Entry first() { return set.first(); } + public Char2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Char2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Char2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Char2ShortMap.Entry last() { return set.last(); } + public Char2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Char2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Char2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Char2ShortMaps @Override public short putAndMoveToLast(char key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(char key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(char key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(char key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(char key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Char2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Char2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Char2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Char2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Char2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Char2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public CharOrderedSet keySet() { if(keys == null) keys = CharSets.synchronize(map.keySet(), mutex); return (CharOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet char2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.char2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/collections/AbstractDoubleCollection.java b/src/main/java/speiger/src/collections/doubles/collections/AbstractDoubleCollection.java index 2a94ba6..95a99c1 100644 --- a/src/main/java/speiger/src/collections/doubles/collections/AbstractDoubleCollection.java +++ b/src/main/java/speiger/src/collections/doubles/collections/AbstractDoubleCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.doubles.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.doubles.lists.DoubleListIterator; import speiger.src.collections.doubles.functions.DoubleConsumer; import speiger.src.collections.doubles.utils.DoubleIterators; import speiger.src.collections.doubles.utils.DoubleArrays; @@ -249,4 +251,68 @@ public abstract class AbstractDoubleCollection extends AbstractCollection size()) a[size()] = 0D; return a; } + + public static class ReverseDoubleOrderedCollection extends AbstractDoubleCollection implements DoubleOrderedCollection { + DoubleOrderedCollection collection; + Supplier reverseIterator; + + public ReverseDoubleOrderedCollection(DoubleOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(double o) { return collection.add(o); } + @Override + public DoubleOrderedCollection reversed() { return collection; } + @Override + public void addFirst(double e) { collection.addLast(e); } + @Override + public void addLast(double e) { collection.addFirst(e); } + @Override + public boolean contains(double e) { return collection.contains(e); } + @Override + public boolean remDouble(double e) { return collection.remDouble(e); } + @Override + public void clear() { collection.clear(); } + @Override + public double getFirstDouble() { return collection.getLastDouble(); } + @Override + public double removeFirstDouble() { return collection.removeLastDouble(); } + @Override + public double getLastDouble() { return collection.getFirstDouble(); } + @Override + public double removeLastDouble() { return collection.removeFirstDouble(); } + @Override + public DoubleIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements DoubleListIterator { + DoubleListIterator it; + + public ReverseBiIterator(DoubleListIterator it) { + this.it = it; + } + + @Override + public double nextDouble() { return it.previousDouble(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public double previousDouble() { return it.nextDouble(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(double e) { it.set(e); } + @Override + public void add(double e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/doubles/collections/DoubleBidirectionalIterator.java b/src/main/java/speiger/src/collections/doubles/collections/DoubleBidirectionalIterator.java index 1992f30..09d3b8b 100644 --- a/src/main/java/speiger/src/collections/doubles/collections/DoubleBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/doubles/collections/DoubleBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.doubles.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface DoubleBidirectionalIterator extends DoubleIterator, ObjectBidirectionalIterator +public interface DoubleBidirectionalIterator extends DoubleIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface DoubleBidirectionalIterator extends DoubleIterator, ObjectBidir */ public double previousDouble(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Double previous() { return Double.valueOf(previousDouble()); diff --git a/src/main/java/speiger/src/collections/doubles/collections/DoubleOrderedCollection.java b/src/main/java/speiger/src/collections/doubles/collections/DoubleOrderedCollection.java new file mode 100644 index 0000000..d07c9ef --- /dev/null +++ b/src/main/java/speiger/src/collections/doubles/collections/DoubleOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.doubles.collections; + +public interface DoubleOrderedCollection extends DoubleCollection { + + DoubleOrderedCollection 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(double 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(double e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public double getFirstDouble(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public double removeFirstDouble(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public double getLastDouble(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public double removeLastDouble(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/doubles/lists/AbstractDoubleList.java b/src/main/java/speiger/src/collections/doubles/lists/AbstractDoubleList.java index a1ec7fe..88519d2 100644 --- a/src/main/java/speiger/src/collections/doubles/lists/AbstractDoubleList.java +++ b/src/main/java/speiger/src/collections/doubles/lists/AbstractDoubleList.java @@ -466,7 +466,6 @@ public abstract class AbstractDoubleList extends AbstractDoubleCollection implem public int size() { return size; } - @Override public DoubleSplititerator spliterator() { return DoubleSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/doubles/lists/DoubleLinkedList.java b/src/main/java/speiger/src/collections/doubles/lists/DoubleLinkedList.java index 5cc8b09..361d12a 100644 --- a/src/main/java/speiger/src/collections/doubles/lists/DoubleLinkedList.java +++ b/src/main/java/speiger/src/collections/doubles/lists/DoubleLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.doubles.functions.DoubleConsumer; import speiger.src.collections.doubles.utils.DoubleArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.DoubleStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.doubles.collections.DoubleSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.doubles.collections.DoubleSplititerator; import speiger.src.collections.doubles.utils.DoubleSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class DoubleLinkedList extends AbstractDoubleList implements DoublePriori if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class DoubleLinkedList extends AbstractDoubleList implements DoublePriori * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public DoubleStream parallelPrimitiveStream() { return StreamSupport.doubleStream(new SplitIterator(this, first, 0), true); } - /** + public DoubleStream parallelPrimitiveStream() { return StreamSupport.doubleStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/doubles/lists/DoubleList.java b/src/main/java/speiger/src/collections/doubles/lists/DoubleList.java index 8e209f5..311fa1d 100644 --- a/src/main/java/speiger/src/collections/doubles/lists/DoubleList.java +++ b/src/main/java/speiger/src/collections/doubles/lists/DoubleList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleSplititerator; import speiger.src.collections.ints.functions.consumer.IntDoubleConsumer; import speiger.src.collections.doubles.functions.DoubleComparator; @@ -20,7 +21,7 @@ import speiger.src.collections.doubles.utils.DoubleSplititerators; /** * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features */ -public interface DoubleList extends DoubleCollection, List +public interface DoubleList extends DoubleOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -83,6 +84,24 @@ public interface DoubleList extends DoubleCollection, List */ public boolean addAll(int index, DoubleList 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(double 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(double e) { + add(e); + } + /** * 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. @@ -413,9 +432,9 @@ public interface DoubleList extends DoubleCollection, List @Override @Deprecated public default boolean add(Double e) { - return DoubleCollection.super.add(e); + return DoubleOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -463,7 +482,7 @@ public interface DoubleList extends DoubleCollection, List @Override @Deprecated public default boolean contains(Object o) { - return DoubleCollection.super.contains(o); + return DoubleOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -473,7 +492,7 @@ public interface DoubleList extends DoubleCollection, List @Override @Deprecated public default boolean remove(Object o) { - return DoubleCollection.super.remove(o); + return DoubleOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2BooleanMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2BooleanMap.java index d9ac97e..56477c6 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2BooleanMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.consumer.DoubleBooleanConsumer; import speiger.src.collections.doubles.functions.function.DoubleBooleanUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2BooleanMap; +import speiger.src.collections.doubles.maps.interfaces.Double2BooleanOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractDouble2BooleanMap extends AbstractMap double2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2BooleanEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ByteMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ByteMap.java index ca0bed0..dc9c598 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ByteMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleByteConsumer; import speiger.src.collections.doubles.functions.function.Double2ByteFunction; import speiger.src.collections.doubles.functions.function.DoubleByteUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2ByteMap; +import speiger.src.collections.doubles.maps.interfaces.Double2ByteOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2ByteMap extends AbstractMap implements Double2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2ByteMap extends AbstractMap i public void putAll(Double[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedDouble2ByteOrderedMap extends AbstractDouble2ByteMap implements Double2ByteOrderedMap { + Double2ByteOrderedMap map; + + public ReversedDouble2ByteOrderedMap(Double2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(double key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(double key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(double key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(double key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(double key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(double key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(double key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Double2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(DoubleByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(double key, DoubleByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(double key, Double2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(double key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(double key, DoubleByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(double key, DoubleByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(double key, Double2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(double key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(double key, DoubleByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(double key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(double key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(double key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(double key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(double key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(double key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(double key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Double2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet double2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2ByteEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2CharMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2CharMap.java index d3f9d26..421e6cb 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2CharMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleCharConsumer; import speiger.src.collections.doubles.functions.function.Double2CharFunction; import speiger.src.collections.doubles.functions.function.DoubleCharUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2CharMap; +import speiger.src.collections.doubles.maps.interfaces.Double2CharOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2CharMap extends AbstractMap implements Double2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2CharMap extends AbstractMap double2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2CharEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2DoubleMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2DoubleMap.java index 8d7e52d..98bac30 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2DoubleMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleDoubleConsumer; import speiger.src.collections.doubles.functions.function.DoubleUnaryOperator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2DoubleMap; +import speiger.src.collections.doubles.maps.interfaces.Double2DoubleOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2DoubleMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2DoubleMap extends AbstractMap implements Double2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractDouble2DoubleMap extends AbstractMap double2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2DoubleEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2FloatMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2FloatMap.java index 09dafe4..dabc858 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2FloatMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleFloatConsumer; import speiger.src.collections.doubles.functions.function.Double2FloatFunction; import speiger.src.collections.doubles.functions.function.DoubleFloatUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2FloatMap; +import speiger.src.collections.doubles.maps.interfaces.Double2FloatOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2FloatMap extends AbstractMap implements Double2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2FloatMap extends AbstractMap public void putAll(Double[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedDouble2FloatOrderedMap extends AbstractDouble2FloatMap implements Double2FloatOrderedMap { + Double2FloatOrderedMap map; + + public ReversedDouble2FloatOrderedMap(Double2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(double key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(double key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(double key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(double key, float value) { return map.subFrom(key, value); } + @Override + public float remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(double key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(double key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(double key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Double2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(DoubleFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(double key, DoubleFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(double key, Double2FloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(double key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(double key, DoubleFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(double key, DoubleFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(double key, Double2FloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(double key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(double key, DoubleFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(double key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(double key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(double key) { return map.get(key); } + @Override + public float putAndMoveToFirst(double key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(double key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(double key, float value) { return map.putLast(key, value); } + @Override + public float putLast(double key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Double2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet double2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2FloatEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2IntMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2IntMap.java index 944e121..9029124 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2IntMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleIntConsumer; import speiger.src.collections.doubles.functions.function.Double2IntFunction; import speiger.src.collections.doubles.functions.function.DoubleIntUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2IntMap; +import speiger.src.collections.doubles.maps.interfaces.Double2IntOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2IntMap extends AbstractMap implements Double2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2IntMap extends AbstractMap public void putAll(Double[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedDouble2IntOrderedMap extends AbstractDouble2IntMap implements Double2IntOrderedMap { + Double2IntOrderedMap map; + + public ReversedDouble2IntOrderedMap(Double2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(double key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(double key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(double key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(double key, int value) { return map.subFrom(key, value); } + @Override + public int remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(double key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(double key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(double key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Double2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(DoubleIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(double key, DoubleIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(double key, Double2IntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(double key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(double key, DoubleIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(double key, DoubleIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(double key, Double2IntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(double key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(double key, DoubleIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(double key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(double key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(double key) { return map.get(key); } + @Override + public int putAndMoveToFirst(double key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(double key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(double key, int value) { return map.putLast(key, value); } + @Override + public int putLast(double key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Double2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet double2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2IntEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2LongMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2LongMap.java index abdbc5e..c9f59ec 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2LongMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleLongConsumer; import speiger.src.collections.doubles.functions.function.Double2LongFunction; import speiger.src.collections.doubles.functions.function.DoubleLongUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2LongMap; +import speiger.src.collections.doubles.maps.interfaces.Double2LongOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2LongMap extends AbstractMap implements Double2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2LongMap extends AbstractMap i public void putAll(Double[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedDouble2LongOrderedMap extends AbstractDouble2LongMap implements Double2LongOrderedMap { + Double2LongOrderedMap map; + + public ReversedDouble2LongOrderedMap(Double2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(double key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(double key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(double key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(double key, long value) { return map.subFrom(key, value); } + @Override + public long remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(double key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(double key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(double key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Double2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(DoubleLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(double key, DoubleLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(double key, Double2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(double key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(double key, DoubleLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(double key, DoubleLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(double key, Double2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(double key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(double key, DoubleLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(double key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(double key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(double key) { return map.get(key); } + @Override + public long putAndMoveToFirst(double key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(double key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(double key, long value) { return map.putLast(key, value); } + @Override + public long putLast(double key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Double2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet double2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2LongEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ObjectMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ObjectMap.java index 7cc1df0..a6a6b24 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ObjectMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleObjectConsumer; import speiger.src.collections.doubles.functions.function.DoubleFunction; import speiger.src.collections.doubles.functions.function.DoubleObjectUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2ObjectMap; +import speiger.src.collections.doubles.maps.interfaces.Double2ObjectOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractDouble2ObjectMap extends AbstractMap public void putAll(Double[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap return hash; } + public static class ReversedDouble2ObjectOrderedMap extends AbstractDouble2ObjectMap implements Double2ObjectOrderedMap { + Double2ObjectOrderedMap map; + + public ReversedDouble2ObjectOrderedMap(Double2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(double key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(double key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(double key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(double key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(double key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Double2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(DoubleObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(double key, DoubleObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(double key, DoubleFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(double key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(double key, DoubleObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(double key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(double key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(double key) { return map.get(key); } + @Override + public V putAndMoveToFirst(double key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(double key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(double key, V value) { return map.putLast(key, value); } + @Override + public V putLast(double key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Double2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> double2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2ObjectEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ShortMap.java b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ShortMap.java index 7aa3bb7..f9c3935 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ShortMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/abstracts/AbstractDouble2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.doubles.functions.consumer.DoubleShortConsumer; import speiger.src.collections.doubles.functions.function.Double2ShortFunction; import speiger.src.collections.doubles.functions.function.DoubleShortUnaryOperator; import speiger.src.collections.doubles.maps.interfaces.Double2ShortMap; +import speiger.src.collections.doubles.maps.interfaces.Double2ShortOrderedMap; +import speiger.src.collections.doubles.sets.DoubleOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.maps.Double2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractDouble2ShortMap extends AbstractMap implements Double2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractDouble2ShortMap extends AbstractMap public void putAll(Double[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedDouble2ShortOrderedMap extends AbstractDouble2ShortMap implements Double2ShortOrderedMap { + Double2ShortOrderedMap map; + + public ReversedDouble2ShortOrderedMap(Double2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractDouble2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Double2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(double key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(double key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(double key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(double key, short value) { return map.subFrom(key, value); } + @Override + public short remove(double key) { return map.remove(key); } + @Override + public boolean remove(double key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(double key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(double key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(double key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(double key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Double2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(DoubleShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(double key, DoubleShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(double key, Double2ShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(double key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(double key, DoubleShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(double key, DoubleShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(double key, Double2ShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(double key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(double key, DoubleShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(double key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(double key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(double key) { return map.get(key); } + @Override + public short putAndMoveToFirst(double key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(double key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(double key, short value) { return map.putLast(key, value); } + @Override + public short putLast(double key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(double key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(double key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(double key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(double key) { return map.getAndMoveToFirst(key); } + @Override + public double firstDoubleKey() { return map.lastDoubleKey(); } + @Override + public double pollFirstDoubleKey() { return map.pollLastDoubleKey(); } + @Override + public double lastDoubleKey() { return map.firstDoubleKey(); } + @Override + public double pollLastDoubleKey() { return map.pollFirstDoubleKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Double2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Double2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Double2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Double2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet double2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.double2ShortEntrySet()); } + @Override + public DoubleOrderedSet keySet() { return new AbstractDoubleSet.ReversedDoubleOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Double2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2BooleanLinkedOpenCustomHashMap.java index 62ec3e9..cd56ef6 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus return getDefaultReturnValue(); } + @Override + public boolean putFirst(double key, boolean value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 boolean putLast(double key, boolean value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus return values[lastIndex]; } + @Override + public Double2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } @Override - public Double2BooleanMap.Entry first() { + public Double2BooleanMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstBooleanValue()); } @Override - public Double2BooleanMap.Entry last() { + public Double2BooleanMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastBooleanValue()); } @Override - public Double2BooleanMap.Entry pollFirst() { + public Double2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstBooleanValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2BooleanMap.Entry pollLast() { + public Double2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastBooleanValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstDoubleKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Double2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2BooleanLinkedOpenCustomHashMap extends Double2BooleanOpenCus public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ByteLinkedOpenCustomHashMap.java index 9ef8bba..9cc51ee 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ByteLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -258,6 +258,54 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas return getDefaultReturnValue(); } + @Override + public byte putFirst(double key, byte value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 byte putLast(double key, byte value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas return values[lastIndex]; } + @Override + public Double2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } @Override - public Double2ByteMap.Entry first() { + public Double2ByteMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstByteValue()); } @Override - public Double2ByteMap.Entry last() { + public Double2ByteMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastByteValue()); } @Override - public Double2ByteMap.Entry pollFirst() { + public Double2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstByteValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ByteMap.Entry pollLast() { + public Double2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastByteValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstDoubleKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Double2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1284,16 +1399,20 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2ByteLinkedOpenCustomHashMap extends Double2ByteOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2CharLinkedOpenCustomHashMap.java index 5771861..aa8bfd4 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2CharLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -258,6 +258,54 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas return getDefaultReturnValue(); } + @Override + public char putFirst(double key, char value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 char putLast(double key, char value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas return values[lastIndex]; } + @Override + public Double2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } @Override - public Double2CharMap.Entry first() { + public Double2CharMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstCharValue()); } @Override - public Double2CharMap.Entry last() { + public Double2CharMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastCharValue()); } @Override - public Double2CharMap.Entry pollFirst() { + public Double2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstCharValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2CharMap.Entry pollLast() { + public Double2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastCharValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstDoubleKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Double2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1284,16 +1399,20 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2CharLinkedOpenCustomHashMap extends Double2CharOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2DoubleLinkedOpenCustomHashMap.java index e266c7c..64a9e3a 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2DoubleLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto return getDefaultReturnValue(); } + @Override + public double putFirst(double key, double value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 double putLast(double key, double value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -386,6 +434,52 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto return values[lastIndex]; } + @Override + public Double2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } @Override - public Double2DoubleMap.Entry first() { + public Double2DoubleMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstDoubleValue()); } @Override - public Double2DoubleMap.Entry last() { + public Double2DoubleMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastDoubleValue()); } @Override - public Double2DoubleMap.Entry pollFirst() { + public Double2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstDoubleValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2DoubleMap.Entry pollLast() { + public Double2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastDoubleValue()); pollLastDoubleKey(); return entry; @@ -611,7 +705,12 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1023,30 +1127,41 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstDoubleKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Double2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1204,7 +1319,7 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1234,7 +1349,7 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1256,7 +1371,7 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1277,16 +1392,20 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Double2DoubleLinkedOpenCustomHashMap extends Double2DoubleOpenCusto public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2FloatLinkedOpenCustomHashMap.java index 67c91a9..a77d317 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2FloatLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -258,6 +258,54 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH return getDefaultReturnValue(); } + @Override + public float putFirst(double key, float value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 float putLast(double key, float value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH return values[lastIndex]; } + @Override + public Double2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } @Override - public Double2FloatMap.Entry first() { + public Double2FloatMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstFloatValue()); } @Override - public Double2FloatMap.Entry last() { + public Double2FloatMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastFloatValue()); } @Override - public Double2FloatMap.Entry pollFirst() { + public Double2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstFloatValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2FloatMap.Entry pollLast() { + public Double2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastFloatValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstDoubleKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Double2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1284,16 +1399,20 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2FloatLinkedOpenCustomHashMap extends Double2FloatOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2IntLinkedOpenCustomHashMap.java index f86c429..2466271 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM return getDefaultReturnValue(); } + @Override + public int putFirst(double key, int value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 int putLast(double key, int value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM return values[lastIndex]; } + @Override + public Double2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } @Override - public Double2IntMap.Entry first() { + public Double2IntMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstIntValue()); } @Override - public Double2IntMap.Entry last() { + public Double2IntMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastIntValue()); } @Override - public Double2IntMap.Entry pollFirst() { + public Double2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstIntValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2IntMap.Entry pollLast() { + public Double2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastIntValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstDoubleKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Double2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2IntLinkedOpenCustomHashMap extends Double2IntOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2LongLinkedOpenCustomHashMap.java index 387ba4e..49e4054 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2LongLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -258,6 +258,54 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas return getDefaultReturnValue(); } + @Override + public long putFirst(double key, long value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 long putLast(double key, long value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas return values[lastIndex]; } + @Override + public Double2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } @Override - public Double2LongMap.Entry first() { + public Double2LongMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstLongValue()); } @Override - public Double2LongMap.Entry last() { + public Double2LongMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastLongValue()); } @Override - public Double2LongMap.Entry pollFirst() { + public Double2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstLongValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2LongMap.Entry pollLast() { + public Double2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastLongValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstDoubleKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Double2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1284,16 +1399,20 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2LongLinkedOpenCustomHashMap extends Double2LongOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ObjectLinkedOpenCustomHashMap.java index 9e8884b..7d1debb 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu return getDefaultReturnValue(); } + @Override + public V putFirst(double key, V value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 V putLast(double key, V value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -388,6 +436,52 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu return values[lastIndex]; } + @Override + public Double2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> double2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } @Override - public Double2ObjectMap.Entry first() { + public Double2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstDoubleKey(), firstValue()); } @Override - public Double2ObjectMap.Entry last() { + public Double2ObjectMap.Entry getLast() { return new BasicEntry<>(lastDoubleKey(), lastValue()); } @Override - public Double2ObjectMap.Entry pollFirst() { + public Double2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstDoubleKey(), firstValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ObjectMap.Entry pollLast() { + public Double2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastDoubleKey(), lastValue()); pollLastDoubleKey(); return entry; @@ -613,7 +707,12 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,31 +1129,42 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Double2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Double2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Double2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Double2ObjectLinkedOpenCustomHashMap extends Double2ObjectOpenCu public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ShortLinkedOpenCustomHashMap.java index 722b917..26bdfab 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/customHash/Double2ShortLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.utils.DoubleStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -258,6 +258,54 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH return getDefaultReturnValue(); } + @Override + public short putFirst(double key, short value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + 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 short putLast(double key, short value) { + if(strategy.equals(key, 0D)) { + 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], 0D)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || strategy.equals(firstDoubleKey(), key)) return false; @@ -393,6 +441,52 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH return values[lastIndex]; } + @Override + public Double2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getDoubleKey(), 0D)) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } @Override - public Double2ShortMap.Entry first() { + public Double2ShortMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstShortValue()); } @Override - public Double2ShortMap.Entry last() { + public Double2ShortMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastShortValue()); } @Override - public Double2ShortMap.Entry pollFirst() { + public Double2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstShortValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ShortMap.Entry pollLast() { + public Double2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastShortValue()); pollLastDoubleKey(); return entry; @@ -618,7 +712,12 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1030,30 +1134,41 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Double2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Double2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstDoubleKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Double2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Double2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastDoubleKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1211,7 +1326,7 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1241,7 +1356,7 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1263,7 +1378,7 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1284,16 +1399,20 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Double2ShortLinkedOpenCustomHashMap extends Double2ShortOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2BooleanLinkedOpenHashMap.java index 37cf4aa..e9c5649 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2BooleanOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i return getDefaultReturnValue(); } + @Override + public boolean putFirst(double key, boolean value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 boolean putLast(double key, boolean value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i return values[lastIndex]; } + @Override + public Double2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } @Override - public Double2BooleanMap.Entry first() { + public Double2BooleanMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstBooleanValue()); } @Override - public Double2BooleanMap.Entry last() { + public Double2BooleanMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastBooleanValue()); } @Override - public Double2BooleanMap.Entry pollFirst() { + public Double2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstBooleanValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2BooleanMap.Entry pollLast() { + public Double2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastBooleanValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Double2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2BooleanLinkedOpenHashMap extends Double2BooleanOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ByteLinkedOpenHashMap.java index b374e33..b855e56 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ByteLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ByteOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -235,6 +235,54 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public byte putFirst(double key, byte value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 byte putLast(double key, byte value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme return values[lastIndex]; } + @Override + public Double2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } @Override - public Double2ByteMap.Entry first() { + public Double2ByteMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstByteValue()); } @Override - public Double2ByteMap.Entry last() { + public Double2ByteMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastByteValue()); } @Override - public Double2ByteMap.Entry pollFirst() { + public Double2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstByteValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ByteMap.Entry pollLast() { + public Double2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastByteValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Double2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1279,13 +1394,16 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2ByteLinkedOpenHashMap extends Double2ByteOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2CharLinkedOpenHashMap.java index 2f70148..0595e93 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2CharLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2CharOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -235,6 +235,54 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public char putFirst(double key, char value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 char putLast(double key, char value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme return values[lastIndex]; } + @Override + public Double2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } @Override - public Double2CharMap.Entry first() { + public Double2CharMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstCharValue()); } @Override - public Double2CharMap.Entry last() { + public Double2CharMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastCharValue()); } @Override - public Double2CharMap.Entry pollFirst() { + public Double2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstCharValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2CharMap.Entry pollLast() { + public Double2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastCharValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2CharLinkedOpenHashMap.this.clear(); + public void clear() { Double2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1279,13 +1394,16 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2CharLinkedOpenHashMap extends Double2CharOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2DoubleLinkedOpenHashMap.java index a9c388b..0a31e86 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2DoubleLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2DoubleOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp return getDefaultReturnValue(); } + @Override + public double putFirst(double key, double value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 double putLast(double key, double value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -384,6 +432,52 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp return values[lastIndex]; } + @Override + public Double2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } @Override - public Double2DoubleMap.Entry first() { + public Double2DoubleMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstDoubleValue()); } @Override - public Double2DoubleMap.Entry last() { + public Double2DoubleMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastDoubleValue()); } @Override - public Double2DoubleMap.Entry pollFirst() { + public Double2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstDoubleValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2DoubleMap.Entry pollLast() { + public Double2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastDoubleValue()); pollLastDoubleKey(); return entry; @@ -609,7 +703,12 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1018,32 +1122,43 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Double2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1200,7 +1315,7 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1230,7 +1345,7 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1252,7 +1367,7 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1272,13 +1387,16 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1309,11 +1427,11 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Double2DoubleLinkedOpenHashMap extends Double2DoubleOpenHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2FloatLinkedOpenHashMap.java index 3c7a60a..9e5104e 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2FloatLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2FloatOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -235,6 +235,54 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple return getDefaultReturnValue(); } + @Override + public float putFirst(double key, float value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 float putLast(double key, float value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple return values[lastIndex]; } + @Override + public Double2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } @Override - public Double2FloatMap.Entry first() { + public Double2FloatMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstFloatValue()); } @Override - public Double2FloatMap.Entry last() { + public Double2FloatMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastFloatValue()); } @Override - public Double2FloatMap.Entry pollFirst() { + public Double2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstFloatValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2FloatMap.Entry pollLast() { + public Double2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastFloatValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Double2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1279,13 +1394,16 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2FloatLinkedOpenHashMap extends Double2FloatOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2IntLinkedOpenHashMap.java index fb9c2ec..127ace2 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2IntOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement return getDefaultReturnValue(); } + @Override + public int putFirst(double key, int value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 int putLast(double key, int value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement return values[lastIndex]; } + @Override + public Double2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } @Override - public Double2IntMap.Entry first() { + public Double2IntMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstIntValue()); } @Override - public Double2IntMap.Entry last() { + public Double2IntMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastIntValue()); } @Override - public Double2IntMap.Entry pollFirst() { + public Double2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstIntValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2IntMap.Entry pollLast() { + public Double2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastIntValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2IntLinkedOpenHashMap.this.clear(); + public void clear() { Double2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2IntLinkedOpenHashMap extends Double2IntOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2LongLinkedOpenHashMap.java index 510351d..223edec 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2LongLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2LongOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -235,6 +235,54 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public long putFirst(double key, long value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 long putLast(double key, long value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme return values[lastIndex]; } + @Override + public Double2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } @Override - public Double2LongMap.Entry first() { + public Double2LongMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstLongValue()); } @Override - public Double2LongMap.Entry last() { + public Double2LongMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastLongValue()); } @Override - public Double2LongMap.Entry pollFirst() { + public Double2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstLongValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2LongMap.Entry pollLast() { + public Double2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastLongValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2LongLinkedOpenHashMap.this.clear(); + public void clear() { Double2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1279,13 +1394,16 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2LongLinkedOpenHashMap extends Double2LongOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ObjectLinkedOpenHashMap.java index fce457f..7799d25 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ObjectOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< return getDefaultReturnValue(); } + @Override + public V putFirst(double key, V value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 V putLast(double key, V value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -375,6 +423,52 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< return values[lastIndex]; } + @Override + public Double2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> double2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } @Override - public Double2ObjectMap.Entry first() { + public Double2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstDoubleKey(), firstValue()); } @Override - public Double2ObjectMap.Entry last() { + public Double2ObjectMap.Entry getLast() { return new BasicEntry<>(lastDoubleKey(), lastValue()); } @Override - public Double2ObjectMap.Entry pollFirst() { + public Double2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstDoubleKey(), firstValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ObjectMap.Entry pollLast() { + public Double2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastDoubleKey(), lastValue()); pollLastDoubleKey(); return entry; @@ -600,7 +694,12 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1009,33 +1113,44 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Double2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1192,7 +1307,7 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1222,7 +1337,7 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1244,7 +1359,7 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1301,11 +1419,11 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Double2ObjectLinkedOpenHashMap extends Double2ObjectOpenHashMap< public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ShortLinkedOpenHashMap.java index f3a9819..81f2e66 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/hash/Double2ShortLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ShortOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -235,6 +235,54 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple return getDefaultReturnValue(); } + @Override + public short putFirst(double key, short value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(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 short putLast(double key, short value) { + if(Double.doubleToLongBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Double.hashCode(key)) & mask; + while(Double.doubleToLongBits(key) == 0) { + if(Double.doubleToLongBits(keys[pos]) == Double.doubleToLongBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(double key) { if(isEmpty() || Double.doubleToLongBits(firstDoubleKey()) == Double.doubleToLongBits(key)) return false; @@ -391,6 +439,52 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple return values[lastIndex]; } + @Override + public Double2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Double2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Double.doubleToLongBits(result.getDoubleKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0D; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet double2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } @Override - public Double2ShortMap.Entry first() { + public Double2ShortMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstShortValue()); } @Override - public Double2ShortMap.Entry last() { + public Double2ShortMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastShortValue()); } @Override - public Double2ShortMap.Entry pollFirst() { + public Double2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstShortValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ShortMap.Entry pollLast() { + public Double2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastShortValue()); pollLastDoubleKey(); return entry; @@ -616,7 +710,12 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { + public double removeLastDouble() { return pollLastDoubleKey(); } @@ -1025,32 +1129,43 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Double2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Double2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Double2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1207,7 +1322,7 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1237,7 +1352,7 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1259,7 +1374,7 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1279,13 +1394,16 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1316,11 +1434,11 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Double2ShortLinkedOpenHashMap extends Double2ShortOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2BooleanOpenHashMap.java index bb78289..ba63b85 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa @Override public boolean putAndMoveToLast(double key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(double key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(double key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa public boolean moveToLast(Double2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2BooleanMap.Entry first() { + public Double2BooleanMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstBooleanValue()); } @Override - public Double2BooleanMap.Entry last() { + public Double2BooleanMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastBooleanValue()); } @Override - public Double2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1211,11 +1250,11 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableDouble2BooleanOpenHashMap extends AbstractDouble2BooleanMa public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ByteOpenHashMap.java index 20c5d0b..fda8ce6 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ByteOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl @Override public byte putAndMoveToLast(double key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(double key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(double key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2ByteEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl public boolean moveToLast(Double2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2ByteMap.Entry first() { + public Double2ByteMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstByteValue()); } @Override - public Double2ByteMap.Entry last() { + public Double2ByteMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastByteValue()); } @Override - public Double2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2ByteOpenHashMap extends AbstractDouble2ByteMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2CharOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2CharOpenHashMap.java index 71ef200..371c271 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2CharOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl @Override public char putAndMoveToLast(double key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(double key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(double key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2CharEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl public boolean moveToLast(Double2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2CharMap.Entry first() { + public Double2CharMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstCharValue()); } @Override - public Double2CharMap.Entry last() { + public Double2CharMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastCharValue()); } @Override - public Double2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2CharOpenHashMap extends AbstractDouble2CharMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2DoubleOpenHashMap.java index ed25c4a..d7e04ab 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2DoubleOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.doubles.utils.DoubleArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap @Override public double putAndMoveToLast(double key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(double key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(double key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2DoubleEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap public boolean moveToLast(Double2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2DoubleMap.Entry first() { + public Double2DoubleMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstDoubleValue()); } @Override - public Double2DoubleMap.Entry last() { + public Double2DoubleMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastDoubleValue()); } @Override - public Double2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1170,13 +1206,16 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1207,11 +1246,11 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableDouble2DoubleOpenHashMap extends AbstractDouble2DoubleMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2FloatOpenHashMap.java index 4a52f97..e1e8c8d 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2FloatOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im @Override public float putAndMoveToLast(double key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(double key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(double key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2FloatEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im public boolean moveToLast(Double2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2FloatMap.Entry first() { + public Double2FloatMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstFloatValue()); } @Override - public Double2FloatMap.Entry last() { + public Double2FloatMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastFloatValue()); } @Override - public Double2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2FloatOpenHashMap extends AbstractDouble2FloatMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2IntOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2IntOpenHashMap.java index a402acb..e5de9d2 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem @Override public int putAndMoveToLast(double key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(double key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(double key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem public boolean moveToLast(Double2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2IntMap.Entry first() { + public Double2IntMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstIntValue()); } @Override - public Double2IntMap.Entry last() { + public Double2IntMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastIntValue()); } @Override - public Double2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2IntOpenHashMap extends AbstractDouble2IntMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2LongOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2LongOpenHashMap.java index 9557acc..44e451a 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2LongOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl @Override public long putAndMoveToLast(double key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(double key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(double key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2LongEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl public boolean moveToLast(Double2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2LongMap.Entry first() { + public Double2LongMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstLongValue()); } @Override - public Double2LongMap.Entry last() { + public Double2LongMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastLongValue()); } @Override - public Double2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2LongOpenHashMap extends AbstractDouble2LongMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ObjectOpenHashMap.java index 090beaa..f48bb9c 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient ObjectCollection valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM @Override public V putAndMoveToLast(double key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(double key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(double key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -344,7 +348,24 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM public V lastValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> double2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM public boolean moveToLast(Double2ObjectMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2ObjectMap.Entry first() { + public Double2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstDoubleKey(), firstValue()); } @Override - public Double2ObjectMap.Entry last() { + public Double2ObjectMap.Entry getLast() { return new BasicEntry<>(lastDoubleKey(), lastValue()); } @Override - public Double2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -902,31 +933,36 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1130,7 +1166,7 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1188,11 +1227,11 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1209,20 +1248,30 @@ public class ImmutableDouble2ObjectOpenHashMap extends AbstractDouble2ObjectM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ShortOpenHashMap.java index 5a03438..66f686b 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/immutable/ImmutableDouble2ShortOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im /** KeySet cache */ protected transient DoubleOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im @Override public short putAndMoveToLast(double key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(double key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(double key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Double2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Double2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Double2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet double2ShortEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im public boolean moveToLast(Double2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Double2ShortMap.Entry first() { + public Double2ShortMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstShortValue()); } @Override - public Double2ShortMap.Entry last() { + public Double2ShortMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastShortValue()); } @Override - public Double2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im @Override public DoubleListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public double firstDouble() { + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableDouble2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableDouble2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(double from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(double from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(double from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1179,13 +1215,16 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(double from) { @@ -1216,11 +1255,11 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableDouble2ShortOpenHashMap extends AbstractDouble2ShortMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2BooleanArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2BooleanArrayMap.java index 4484085..3b91ce4 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2BooleanOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements return lastValue; } + @Override + public boolean putFirst(double key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(double key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements return result; } + @Override + public Double2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(double key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } @Override - public Double2BooleanMap.Entry first() { + public Double2BooleanMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstBooleanValue()); } @Override - public Double2BooleanMap.Entry last() { + public Double2BooleanMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastBooleanValue()); } @Override - public Double2BooleanMap.Entry pollFirst() { + public Double2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstBooleanValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2BooleanMap.Entry pollLast() { + public Double2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastBooleanValue()); pollLastDoubleKey(); return entry; @@ -720,7 +769,12 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements @Override public boolean moveToLast(double o) { return Double2BooleanArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements @Override public void clear() { Double2BooleanArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2BooleanArrayMap.this.size(); - } - + public int size() { return Double2BooleanArrayMap.this.size(); } @Override - public void clear() { - Double2BooleanArrayMap.this.clear(); + public void clear() { Double2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1233,6 +1292,9 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Double2BooleanArrayMap extends AbstractDouble2BooleanMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ByteArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ByteArrayMap.java index 3f204f7..793f479 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ByteArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ByteOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -63,7 +63,7 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl return lastValue; } + @Override + public byte putFirst(double key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(double key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl return result; } + @Override + public Double2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } @Override - public Double2ByteMap.Entry first() { + public Double2ByteMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstByteValue()); } @Override - public Double2ByteMap.Entry last() { + public Double2ByteMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastByteValue()); } @Override - public Double2ByteMap.Entry pollFirst() { + public Double2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstByteValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ByteMap.Entry pollLast() { + public Double2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastByteValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl @Override public boolean moveToLast(double o) { return Double2ByteArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl @Override public void clear() { Double2ByteArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ByteArrayMap.this.size(); - } - + public int size() { return Double2ByteArrayMap.this.size(); } @Override - public void clear() { - Double2ByteArrayMap.this.clear(); + public void clear() { Double2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2ByteMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2ByteMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2ByteArrayMap extends AbstractDouble2ByteMap implements Doubl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2CharArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2CharArrayMap.java index 453105f..fded329 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2CharArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2CharOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -63,7 +63,7 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl return lastValue; } + @Override + public char putFirst(double key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(double key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl return result; } + @Override + public Double2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } @Override - public Double2CharMap.Entry first() { + public Double2CharMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstCharValue()); } @Override - public Double2CharMap.Entry last() { + public Double2CharMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastCharValue()); } @Override - public Double2CharMap.Entry pollFirst() { + public Double2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstCharValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2CharMap.Entry pollLast() { + public Double2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastCharValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl @Override public boolean moveToLast(double o) { return Double2CharArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl @Override public void clear() { Double2CharArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2CharArrayMap.this.size(); - } - + public int size() { return Double2CharArrayMap.this.size(); } @Override - public void clear() { - Double2CharArrayMap.this.clear(); + public void clear() { Double2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2CharMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2CharMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2CharArrayMap extends AbstractDouble2CharMap implements Doubl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2DoubleArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2DoubleArrayMap.java index 0f09fa0..4daf86c 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2DoubleArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2DoubleOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D return lastValue; } + @Override + public double putFirst(double key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(double key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D return result; } + @Override + public Double2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(double key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } @Override - public Double2DoubleMap.Entry first() { + public Double2DoubleMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstDoubleValue()); } @Override - public Double2DoubleMap.Entry last() { + public Double2DoubleMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastDoubleValue()); } @Override - public Double2DoubleMap.Entry pollFirst() { + public Double2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstDoubleValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2DoubleMap.Entry pollLast() { + public Double2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastDoubleValue()); pollLastDoubleKey(); return entry; @@ -736,7 +785,12 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D @Override public boolean moveToLast(double o) { return Double2DoubleArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D @Override public void clear() { Double2DoubleArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2DoubleArrayMap.this.size(); - } - + public int size() { return Double2DoubleArrayMap.this.size(); } @Override - public void clear() { - Double2DoubleArrayMap.this.clear(); + public void clear() { Double2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2DoubleMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2DoubleMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1249,6 +1308,9 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Double2DoubleArrayMap extends AbstractDouble2DoubleMap implements D public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2FloatArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2FloatArrayMap.java index d5fdacc..ef9bec0 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2FloatArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2FloatOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -63,7 +63,7 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou return lastValue; } + @Override + public float putFirst(double key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(double key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou return result; } + @Override + public Double2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } @Override - public Double2FloatMap.Entry first() { + public Double2FloatMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstFloatValue()); } @Override - public Double2FloatMap.Entry last() { + public Double2FloatMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastFloatValue()); } @Override - public Double2FloatMap.Entry pollFirst() { + public Double2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstFloatValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2FloatMap.Entry pollLast() { + public Double2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastFloatValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou @Override public boolean moveToLast(double o) { return Double2FloatArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou @Override public void clear() { Double2FloatArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2FloatArrayMap.this.size(); - } - + public int size() { return Double2FloatArrayMap.this.size(); } @Override - public void clear() { - Double2FloatArrayMap.this.clear(); + public void clear() { Double2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2FloatMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2FloatMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2FloatArrayMap extends AbstractDouble2FloatMap implements Dou public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2IntArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2IntArrayMap.java index b97624c..390747e 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2IntOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 return lastValue; } + @Override + public int putFirst(double key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(double key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 return result; } + @Override + public Double2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } @Override - public Double2IntMap.Entry first() { + public Double2IntMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstIntValue()); } @Override - public Double2IntMap.Entry last() { + public Double2IntMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastIntValue()); } @Override - public Double2IntMap.Entry pollFirst() { + public Double2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstIntValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2IntMap.Entry pollLast() { + public Double2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastIntValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 @Override public boolean moveToLast(double o) { return Double2IntArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 @Override public void clear() { Double2IntArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2IntArrayMap.this.size(); - } - + public int size() { return Double2IntArrayMap.this.size(); } @Override - public void clear() { - Double2IntArrayMap.this.clear(); + public void clear() { Double2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2IntArrayMap extends AbstractDouble2IntMap implements Double2 public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2LongArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2LongArrayMap.java index ed949e9..d6008b5 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2LongArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2LongOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -63,7 +63,7 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl return lastValue; } + @Override + public long putFirst(double key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(double key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl return result; } + @Override + public Double2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } @Override - public Double2LongMap.Entry first() { + public Double2LongMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstLongValue()); } @Override - public Double2LongMap.Entry last() { + public Double2LongMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastLongValue()); } @Override - public Double2LongMap.Entry pollFirst() { + public Double2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstLongValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2LongMap.Entry pollLast() { + public Double2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastLongValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl @Override public boolean moveToLast(double o) { return Double2LongArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl @Override public void clear() { Double2LongArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2LongArrayMap.this.size(); - } - + public int size() { return Double2LongArrayMap.this.size(); } @Override - public void clear() { - Double2LongArrayMap.this.clear(); + public void clear() { Double2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2LongMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2LongMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2LongArrayMap extends AbstractDouble2LongMap implements Doubl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ObjectArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ObjectArrayMap.java index 383824f..ac22173 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ObjectOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem return lastValue; } + @Override + public V putFirst(double key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(double key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem return result; } + @Override + public Double2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Double2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Double2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(double key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } @Override - public Double2ObjectMap.Entry first() { + public Double2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstDoubleKey(), firstValue()); } @Override - public Double2ObjectMap.Entry last() { + public Double2ObjectMap.Entry getLast() { return new BasicEntry<>(lastDoubleKey(), lastValue()); } @Override - public Double2ObjectMap.Entry pollFirst() { + public Double2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstDoubleKey(), firstValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ObjectMap.Entry pollLast() { + public Double2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastDoubleKey(), lastValue()); pollLastDoubleKey(); return entry; @@ -656,7 +705,12 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem @Override public boolean moveToLast(double o) { return Double2ObjectArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem @Override public void clear() { Double2ObjectArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ObjectArrayMap.this.size(); - } - + public int size() { return Double2ObjectArrayMap.this.size(); } @Override - public void clear() { - Double2ObjectArrayMap.this.clear(); + public void clear() { Double2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1169,6 +1228,9 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Double2ObjectArrayMap extends AbstractDouble2ObjectMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ShortArrayMap.java b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ShortArrayMap.java index 1c45eb9..777da39 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/impl/misc/Double2ShortArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.doubles.maps.interfaces.Double2ShortOrderedMap; import speiger.src.collections.doubles.sets.AbstractDoubleSet; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -63,7 +63,7 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou /** KeySet cache */ protected DoubleOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou return lastValue; } + @Override + public short putFirst(double key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(double key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(double key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou return result; } + @Override + public Double2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Double2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Double2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Double2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(double key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } @Override - public Double2ShortMap.Entry first() { + public Double2ShortMap.Entry getFirst() { return new BasicEntry(firstDoubleKey(), firstShortValue()); } @Override - public Double2ShortMap.Entry last() { + public Double2ShortMap.Entry getLast() { return new BasicEntry(lastDoubleKey(), lastShortValue()); } @Override - public Double2ShortMap.Entry pollFirst() { + public Double2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstDoubleKey(), firstShortValue()); pollFirstDoubleKey(); return entry; } @Override - public Double2ShortMap.Entry pollLast() { + public Double2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastDoubleKey(), lastShortValue()); pollLastDoubleKey(); return entry; @@ -743,7 +792,12 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou @Override public boolean moveToLast(double o) { return Double2ShortArrayMap.this.moveToLast(o); } @Override - public DoubleListIterator iterator() { return new KeyIterator(); } + public DoubleListIterator iterator() { return new KeyIterator(true); } + @Override + public DoubleListIterator reverseIterator() { return new KeyIterator(false); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou @Override public void clear() { Double2ShortArrayMap.this.clear(); } @Override - public double firstDouble() { return firstDoubleKey(); } + public double getFirstDouble() { return firstDoubleKey(); } @Override - public double pollFirstDouble() { return pollFirstDoubleKey(); } + public double removeFirstDouble() { return pollFirstDoubleKey(); } @Override - public double lastDouble() { return lastDoubleKey(); } + public double getLastDouble() { return lastDoubleKey(); } @Override - public double pollLastDouble() { return pollLastDoubleKey(); } + public double removeLastDouble() { return pollLastDoubleKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Double2ShortArrayMap.this.size(); - } - + public int size() { return Double2ShortArrayMap.this.size(); } @Override - public void clear() { - Double2ShortArrayMap.this.clear(); + public void clear() { Double2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstDoubleKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastDoubleKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(double from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(double element) { super(element); } @Override public Double2ShortMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(double from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(double element) { super(element); } @Override public Double2ShortMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } private class KeyIterator extends MapIterator implements DoubleListIterator { - public KeyIterator() {} - public KeyIterator(double element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(double element) { super(element); } @Override public double previousDouble() { @@ -1256,6 +1315,9 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(double element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(double element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Double2ShortArrayMap extends AbstractDouble2ShortMap implements Dou public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanMap.java index 7a5dc21..9a6ee30 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanMap.java @@ -94,7 +94,7 @@ public interface Double2BooleanMap extends Map, DoublePredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanOrderedMap.java index e9ef3e8..e98ab1c 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2BooleanMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2BooleanOrderedMap extends Double2BooleanMap */ public boolean putAndMoveToLast(double key, boolean 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 boolean putFirst(double key, boolean 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 boolean putLast(double key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2BooleanOrderedMap extends Double2BooleanMap */ public boolean lastBooleanValue(); + + public Double2BooleanMap.Entry firstEntry(); + + public Double2BooleanMap.Entry lastEntry(); + + public Double2BooleanMap.Entry pollFirstEntry(); + + public Double2BooleanMap.Entry pollLastEntry(); @Override public Double2BooleanOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet double2BooleanEntrySet(); + public default Double2BooleanOrderedMap reversed() { return new AbstractDouble2BooleanMap.ReversedDouble2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteMap.java index 91dbf28..6f2710e 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteMap.java @@ -94,7 +94,7 @@ public interface Double2ByteMap extends Map, Double2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteOrderedMap.java index 06a341e..13a992f 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2ByteMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2ByteOrderedMap extends Double2ByteMap */ public byte putAndMoveToLast(double key, byte 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 byte putFirst(double key, byte 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 byte putLast(double key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2ByteOrderedMap extends Double2ByteMap */ public byte lastByteValue(); + + public Double2ByteMap.Entry firstEntry(); + + public Double2ByteMap.Entry lastEntry(); + + public Double2ByteMap.Entry pollFirstEntry(); + + public Double2ByteMap.Entry pollLastEntry(); @Override public Double2ByteOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet double2ByteEntrySet(); + public default Double2ByteOrderedMap reversed() { return new AbstractDouble2ByteMap.ReversedDouble2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharMap.java index 97d15e3..2ba2e91 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharMap.java @@ -94,7 +94,7 @@ public interface Double2CharMap extends Map, Double2CharFunct * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharOrderedMap.java index 1229281..41c544b 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2CharMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2CharOrderedMap extends Double2CharMap */ public char putAndMoveToLast(double key, char 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 char putFirst(double key, char 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 char putLast(double key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2CharOrderedMap extends Double2CharMap */ public char lastCharValue(); + + public Double2CharMap.Entry firstEntry(); + + public Double2CharMap.Entry lastEntry(); + + public Double2CharMap.Entry pollFirstEntry(); + + public Double2CharMap.Entry pollLastEntry(); @Override public Double2CharOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet double2CharEntrySet(); + public default Double2CharOrderedMap reversed() { return new AbstractDouble2CharMap.ReversedDouble2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleMap.java index f35a531..45b950c 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleMap.java @@ -93,7 +93,7 @@ public interface Double2DoubleMap extends Map, DoubleUnaryOperat * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleOrderedMap.java index 1b881b6..64a0372 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2DoubleMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2DoubleOrderedMap extends Double2DoubleMap */ public double putAndMoveToLast(double key, double 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 double putFirst(double key, double 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 double putLast(double key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2DoubleOrderedMap extends Double2DoubleMap */ public double lastDoubleValue(); + + public Double2DoubleMap.Entry firstEntry(); + + public Double2DoubleMap.Entry lastEntry(); + + public Double2DoubleMap.Entry pollFirstEntry(); + + public Double2DoubleMap.Entry pollLastEntry(); @Override public Double2DoubleOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet double2DoubleEntrySet(); + public default Double2DoubleOrderedMap reversed() { return new AbstractDouble2DoubleMap.ReversedDouble2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatMap.java index 8c6f502..f8d70b4 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatMap.java @@ -94,7 +94,7 @@ public interface Double2FloatMap extends Map, Double2FloatFunctio * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatOrderedMap.java index 04a589c..ac1e836 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2FloatMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2FloatOrderedMap extends Double2FloatMap */ public float putAndMoveToLast(double key, float 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 float putFirst(double key, float 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 float putLast(double key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2FloatOrderedMap extends Double2FloatMap */ public float lastFloatValue(); + + public Double2FloatMap.Entry firstEntry(); + + public Double2FloatMap.Entry lastEntry(); + + public Double2FloatMap.Entry pollFirstEntry(); + + public Double2FloatMap.Entry pollLastEntry(); @Override public Double2FloatOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet double2FloatEntrySet(); + public default Double2FloatOrderedMap reversed() { return new AbstractDouble2FloatMap.ReversedDouble2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntMap.java index 1a79d67..51c6b46 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntMap.java @@ -94,7 +94,7 @@ public interface Double2IntMap extends Map, Double2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntOrderedMap.java index 90aeba1..87b9fac 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2IntMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2IntOrderedMap extends Double2IntMap */ public int putAndMoveToLast(double key, int 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 int putFirst(double key, int 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 int putLast(double key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2IntOrderedMap extends Double2IntMap */ public int lastIntValue(); + + public Double2IntMap.Entry firstEntry(); + + public Double2IntMap.Entry lastEntry(); + + public Double2IntMap.Entry pollFirstEntry(); + + public Double2IntMap.Entry pollLastEntry(); @Override public Double2IntOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet double2IntEntrySet(); + public default Double2IntOrderedMap reversed() { return new AbstractDouble2IntMap.ReversedDouble2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongMap.java index 9db6cb3..289e212 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongMap.java @@ -94,7 +94,7 @@ public interface Double2LongMap extends Map, Double2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongOrderedMap.java index 8ed73c5..5de4ce0 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2LongMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2LongOrderedMap extends Double2LongMap */ public long putAndMoveToLast(double key, long 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 long putFirst(double key, long 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 long putLast(double key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2LongOrderedMap extends Double2LongMap */ public long lastLongValue(); + + public Double2LongMap.Entry firstEntry(); + + public Double2LongMap.Entry lastEntry(); + + public Double2LongMap.Entry pollFirstEntry(); + + public Double2LongMap.Entry pollLastEntry(); @Override public Double2LongOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet double2LongEntrySet(); + public default Double2LongOrderedMap reversed() { return new AbstractDouble2LongMap.ReversedDouble2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectMap.java index 52ff5d0..d565d0e 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectMap.java @@ -95,7 +95,7 @@ public interface Double2ObjectMap extends Map, DoubleFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectOrderedMap.java index 211ea75..0151349 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2ObjectMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Double2ObjectOrderedMap extends Double2ObjectMap */ public V putAndMoveToLast(double key, V 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 V putFirst(double key, V 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 V putLast(double key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Double2ObjectOrderedMap extends Double2ObjectMap */ public V lastValue(); + + public Double2ObjectMap.Entry firstEntry(); + + public Double2ObjectMap.Entry lastEntry(); + + public Double2ObjectMap.Entry pollFirstEntry(); + + public Double2ObjectMap.Entry pollLastEntry(); @Override public Double2ObjectOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> double2ObjectEntrySet(); + public default Double2ObjectOrderedMap reversed() { return new AbstractDouble2ObjectMap.ReversedDouble2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortMap.java index e196423..43ef8cc 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortMap.java @@ -94,7 +94,7 @@ public interface Double2ShortMap extends Map, Double2ShortFunctio * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().doubleValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortOrderedMap.java b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortOrderedMap.java index 1f84ddd..f281c62 100644 --- a/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/doubles/maps/interfaces/Double2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.doubles.maps.interfaces; import speiger.src.collections.doubles.utils.maps.Double2ShortMaps; +import speiger.src.collections.doubles.maps.abstracts.AbstractDouble2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Double2ShortOrderedMap extends Double2ShortMap */ public short putAndMoveToLast(double key, short 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 short putFirst(double key, short 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 short putLast(double key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Double2ShortOrderedMap extends Double2ShortMap */ public short lastShortValue(); + + public Double2ShortMap.Entry firstEntry(); + + public Double2ShortMap.Entry lastEntry(); + + public Double2ShortMap.Entry pollFirstEntry(); + + public Double2ShortMap.Entry pollLastEntry(); @Override public Double2ShortOrderedMap copy(); @Override public DoubleOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet double2ShortEntrySet(); + public default Double2ShortOrderedMap reversed() { return new AbstractDouble2ShortMap.ReversedDouble2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/sets/AbstractDoubleSet.java b/src/main/java/speiger/src/collections/doubles/sets/AbstractDoubleSet.java index d006f63..c054dc9 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/AbstractDoubleSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/AbstractDoubleSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.doubles.sets; import java.util.Set; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; +import speiger.src.collections.doubles.collections.DoubleBidirectionalIterator; import speiger.src.collections.doubles.collections.DoubleIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractDoubleSet extends AbstractDoubleCollection impleme return false; } } + + public static class ReversedDoubleOrderedSet extends AbstractDoubleSet implements DoubleOrderedSet { + protected DoubleOrderedSet set; + + public ReversedDoubleOrderedSet(DoubleOrderedSet set) { + this.set = set; + } + + @Override + public ReversedDoubleOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public DoubleBidirectionalIterator iterator(double fromElement) { + return set.iterator(fromElement); + } + + @Override + public DoubleBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public DoubleBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(double o) { + return set.remove(o); + } + + @Override + public boolean add(double o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(double o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(double o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(double o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(double o) { + return set.moveToFirst(o); + } + + @Override + public double getFirstDouble() { + return set.getLastDouble(); + } + + @Override + public double removeFirstDouble() { + return set.removeLastDouble(); + } + + @Override + public double getLastDouble() { + return set.getFirstDouble(); + } + + @Override + public double removeLastDouble() { + return set.removeFirstDouble(); + } + + @Override + public DoubleOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleArraySet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleArraySet.java index 067348c..32b56d5 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleArraySet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleArraySet.java @@ -185,13 +185,13 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe } @Override - public double firstDouble() { + public double getFirstDouble() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public double lastDouble() { + public double getLastDouble() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -282,7 +282,7 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { if(size == 0) throw new NoSuchElementException(); double result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -290,7 +290,7 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe } @Override - public double pollLastDouble() { + public double removeLastDouble() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -413,13 +413,18 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe @Override public DoubleBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public DoubleBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public DoubleBidirectionalIterator iterator(double fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -470,45 +475,57 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe } private class SetIterator implements DoubleListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public double nextDouble() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public double previousDouble() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -528,15 +545,23 @@ public class DoubleArraySet extends AbstractDoubleSet implements DoubleOrderedSe @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenCustomHashSet.java index 5a5a482..036b307 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public boolean moveToFirst(double o) { - if(isEmpty() || strategy.equals(firstDouble(), o)) return false; + if(isEmpty() || strategy.equals(getFirstDouble(), o)) return false; if(strategy.equals(o, 0D)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public boolean moveToLast(double o) { - if(isEmpty() || strategy.equals(lastDouble(), o)) return false; + if(isEmpty() || strategy.equals(getLastDouble(), o)) return false; if(strategy.equals(o, 0D)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple } @Override - public double firstDouble() { + public double getFirstDouble() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple } @Override - public double lastDouble() { + public double getLastDouble() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public double pollLastDouble() { + public double removeLastDouble() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public DoubleListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple } private class SetIterator implements DoubleListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(double from) { + this.forward = true; if(strategy.equals(from, 0D)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public double previousDouble() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class DoubleLinkedOpenCustomHashSet extends DoubleOpenCustomHashSet imple @Override public double nextDouble() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenHashSet.java index 3cbc80c..36c374b 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public boolean moveToFirst(double o) { - if(isEmpty() || Double.doubleToLongBits(firstDouble()) == Double.doubleToLongBits(o)) return false; + if(isEmpty() || Double.doubleToLongBits(getFirstDouble()) == Double.doubleToLongBits(o)) return false; if(Double.doubleToLongBits(o) == 0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public boolean moveToLast(double o) { - if(isEmpty() || Double.doubleToLongBits(lastDouble()) == Double.doubleToLongBits(o)) return false; + if(isEmpty() || Double.doubleToLongBits(getLastDouble()) == Double.doubleToLongBits(o)) return false; if(Double.doubleToLongBits(o) == 0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double } @Override - public double firstDouble() { + public double getFirstDouble() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public double pollFirstDouble() { + public double removeFirstDouble() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double } @Override - public double lastDouble() { + public double getLastDouble() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public double pollLastDouble() { + public double removeLastDouble() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public DoubleListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double } private class SetIterator implements DoubleListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(double from) { + this.forward = true; if(Double.doubleToLongBits(from) == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public double previousDouble() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class DoubleLinkedOpenHashSet extends DoubleOpenHashSet implements Double @Override public double nextDouble() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleNavigableSet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleNavigableSet.java index 85149a3..a16804b 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleNavigableSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.doubles.collections.DoubleBidirectionalIterator; import speiger.src.collections.doubles.collections.DoubleSplititerator; -import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.doubles.utils.DoubleSplititerators; +import speiger.src.collections.doubles.utils.DoubleSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleOrderedSet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleOrderedSet.java index 8bd99ba..91d7c6b 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleOrderedSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.doubles.sets; import speiger.src.collections.doubles.collections.DoubleBidirectionalIterator; import speiger.src.collections.doubles.collections.DoubleSplititerator; -import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.doubles.utils.DoubleSplititerators; +import speiger.src.collections.doubles.sets.AbstractDoubleSet.ReversedDoubleOrderedSet; +import speiger.src.collections.doubles.utils.DoubleSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface DoubleOrderedSet extends DoubleSet @Override public DoubleBidirectionalIterator iterator(); + public DoubleBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface DoubleOrderedSet extends DoubleSet * A method to get the first element in the set * @return first element in the set */ - public double firstDouble(); + public double getFirstDouble(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public double pollFirstDouble(); + public double removeFirstDouble(); /** * A method to get the last element in the set * @return last element in the set */ - public double lastDouble(); + public double getLastDouble(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public double pollLastDouble(); + public double removeLastDouble(); + + public default DoubleOrderedSet reversed() { return new ReversedDoubleOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/doubles/sets/DoubleSet.java b/src/main/java/speiger/src/collections/doubles/sets/DoubleSet.java index 1943eb2..dd19bc4 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/DoubleSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/DoubleSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.doubles.collections.DoubleCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.collections.DoubleSplititerator; -import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.doubles.utils.DoubleSplititerators; +import speiger.src.collections.doubles.utils.DoubleSets; /** diff --git a/src/main/java/speiger/src/collections/doubles/sets/ImmutableDoubleOpenHashSet.java b/src/main/java/speiger/src/collections/doubles/sets/ImmutableDoubleOpenHashSet.java index 36b0ead..cca2eb8 100644 --- a/src/main/java/speiger/src/collections/doubles/sets/ImmutableDoubleOpenHashSet.java +++ b/src/main/java/speiger/src/collections/doubles/sets/ImmutableDoubleOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou } @Override - public double firstDouble() { + public double getFirstDouble() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { + public double getLastDouble() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou @Override public DoubleListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public DoubleListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou } private class SetIterator implements DoubleListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(double from) { + this.forward = true; if(Double.doubleToLongBits(from) == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou @Override public double previousDouble() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableDoubleOpenHashSet extends AbstractDoubleSet implements Dou @Override public double nextDouble() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/doubles/utils/DoubleCollections.java b/src/main/java/speiger/src/collections/doubles/utils/DoubleCollections.java index 26212f6..b2a5af8 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/DoubleCollections.java +++ b/src/main/java/speiger/src/collections/doubles/utils/DoubleCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -50,6 +51,34 @@ public class DoubleCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static DoubleOrderedCollection unmodifiable(DoubleOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static DoubleOrderedCollection synchronize(DoubleOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static DoubleOrderedCollection synchronize(DoubleOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -583,6 +612,37 @@ public class DoubleCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements DoubleOrderedCollection { + DoubleOrderedCollection c; + + SynchronizedOrderedCollection(DoubleOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(DoubleOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public DoubleOrderedCollection reversed() { return DoubleCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(double e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(double e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public double getFirstDouble() { synchronized(mutex) { return this.c.getFirstDouble(); } } + @Override + public double removeFirstDouble() { synchronized(mutex) { return this.c.removeFirstDouble(); } } + @Override + public double getLastDouble() { synchronized(mutex) { return this.c.getLastDouble(); } } + @Override + public double removeLastDouble() { synchronized(mutex) { return this.c.removeLastDouble(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -704,6 +764,33 @@ public class DoubleCollections public int count(DoublePredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements DoubleOrderedCollection { + DoubleOrderedCollection c; + + UnmodifiableOrderedCollection(DoubleOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public DoubleOrderedCollection reversed() { return DoubleCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return c.getFirstDouble(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return c.getLastDouble(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/doubles/utils/DoubleIterators.java b/src/main/java/speiger/src/collections/doubles/utils/DoubleIterators.java index 40d58c1..4076633 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/DoubleIterators.java +++ b/src/main/java/speiger/src/collections/doubles/utils/DoubleIterators.java @@ -34,7 +34,7 @@ public class DoubleIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static DoubleListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class DoubleIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(double... a) { + public static DoubleIterator wrap(double... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class DoubleIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(double[] a, int start, int end) { + public static DoubleIterator wrap(double[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/doubles/utils/DoubleLists.java b/src/main/java/speiger/src/collections/doubles/utils/DoubleLists.java index 78e9432..743594d 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/DoubleLists.java +++ b/src/main/java/speiger/src/collections/doubles/utils/DoubleLists.java @@ -30,7 +30,7 @@ public class DoubleLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static DoubleList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/doubles/utils/DoubleSets.java b/src/main/java/speiger/src/collections/doubles/utils/DoubleSets.java index 990413b..23d6949 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/DoubleSets.java +++ b/src/main/java/speiger/src/collections/doubles/utils/DoubleSets.java @@ -312,17 +312,19 @@ public class DoubleSets @Override public DoubleBidirectionalIterator iterator() { return DoubleIterators.unmodifiable(s.iterator()); } @Override + public DoubleBidirectionalIterator reverseIterator() { return DoubleIterators.unmodifiable(s.reverseIterator()); } + @Override public DoubleBidirectionalIterator iterator(double fromElement) { return DoubleIterators.unmodifiable(s.iterator(fromElement)); } @Override public DoubleOrderedSet copy() { return s.copy(); } @Override - public double firstDouble() { return s.firstDouble(); } + public double getFirstDouble() { return s.getFirstDouble(); } @Override - public double pollFirstDouble() { throw new UnsupportedOperationException(); } + public double removeFirstDouble() { throw new UnsupportedOperationException(); } @Override - public double lastDouble() { return s.lastDouble(); } + public double getLastDouble() { return s.getLastDouble(); } @Override - public double pollLastDouble() { throw new UnsupportedOperationException(); } + public double removeLastDouble() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements DoubleSortedSet @@ -583,17 +585,19 @@ public class DoubleSets @Override public DoubleBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public DoubleBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public DoubleBidirectionalIterator iterator(double fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public DoubleOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public double firstDouble() { synchronized(mutex) { return s.firstDouble(); } } + public double getFirstDouble() { synchronized(mutex) { return s.getFirstDouble(); } } @Override - public double pollFirstDouble() { synchronized(mutex) { return s.pollFirstDouble(); } } + public double removeFirstDouble() { synchronized(mutex) { return s.removeFirstDouble(); } } @Override - public double lastDouble() { synchronized(mutex) { return s.lastDouble(); } } + public double getLastDouble() { synchronized(mutex) { return s.getLastDouble(); } } @Override - public double pollLastDouble() { synchronized(mutex) { return s.pollLastDouble(); } } + public double removeLastDouble() { synchronized(mutex) { return s.removeLastDouble(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2BooleanMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2BooleanMaps.java index 541ec03..39ee34f 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Double2BooleanMaps @Override public boolean putAndMoveToLast(double key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(double key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(double key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Double2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Double2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2BooleanOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet double2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Double2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2BooleanMap.Entry first() { return set.first(); } + public Double2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2BooleanMap.Entry last() { return set.last(); } + public Double2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Double2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Double2BooleanMaps @Override public boolean putAndMoveToLast(double key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(double key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(double key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Double2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Double2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet double2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ByteMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ByteMaps.java index e47407f..3801fd5 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ByteMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Double2ByteMaps @Override public byte putAndMoveToLast(double key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(double key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(double key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Double2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2ByteOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet double2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Double2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2ByteMap.Entry first() { return set.first(); } + public Double2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ByteMap.Entry last() { return set.last(); } + public Double2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Double2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2ByteMaps @Override public byte putAndMoveToLast(double key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(double key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(double key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Double2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet double2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2CharMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2CharMaps.java index d6c61ae..8b1ffa9 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2CharMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Double2CharMaps @Override public char putAndMoveToLast(double key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(double key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(double key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Double2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2CharOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet double2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2CharEntrySet()); @@ -617,15 +634,17 @@ public class Double2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2CharMap.Entry first() { return set.first(); } + public Double2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2CharMap.Entry last() { return set.last(); } + public Double2CharMap.Entry getLast() { return set.getLast(); } @Override - public Double2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2CharMaps @Override public char putAndMoveToLast(double key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(double key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(double key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Double2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet double2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2DoubleMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2DoubleMaps.java index 90d05d8..4eb5169 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -438,6 +439,10 @@ public class Double2DoubleMaps @Override public double putAndMoveToLast(double key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(double key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(double key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Double2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Double2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2DoubleOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet double2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2DoubleEntrySet()); @@ -616,15 +633,17 @@ public class Double2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2DoubleMap.Entry first() { return set.first(); } + public Double2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2DoubleMap.Entry last() { return set.last(); } + public Double2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Double2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Double2DoubleMaps @Override public double putAndMoveToLast(double key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(double key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(double key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Double2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Double2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet double2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2FloatMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2FloatMaps.java index 4f8821c..ccb7eb0 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2FloatMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Double2FloatMaps @Override public float putAndMoveToLast(double key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(double key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(double key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Double2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2FloatOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet double2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Double2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2FloatMap.Entry first() { return set.first(); } + public Double2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2FloatMap.Entry last() { return set.last(); } + public Double2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Double2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2FloatMaps @Override public float putAndMoveToLast(double key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(double key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(double key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Double2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet double2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2IntMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2IntMaps.java index 6f5496b..fa9a894 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2IntMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Double2IntMaps @Override public int putAndMoveToLast(double key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(double key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(double key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Double2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2IntOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet double2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2IntEntrySet()); @@ -617,15 +634,17 @@ public class Double2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2IntMap.Entry first() { return set.first(); } + public Double2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2IntMap.Entry last() { return set.last(); } + public Double2IntMap.Entry getLast() { return set.getLast(); } @Override - public Double2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2IntMaps @Override public int putAndMoveToLast(double key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(double key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(double key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Double2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet double2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2LongMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2LongMaps.java index 909dc12..6367af0 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2LongMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Double2LongMaps @Override public long putAndMoveToLast(double key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(double key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(double key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Double2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2LongOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet double2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2LongEntrySet()); @@ -617,15 +634,17 @@ public class Double2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2LongMap.Entry first() { return set.first(); } + public Double2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2LongMap.Entry last() { return set.last(); } + public Double2LongMap.Entry getLast() { return set.getLast(); } @Override - public Double2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2LongMaps @Override public long putAndMoveToLast(double key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(double key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(double key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Double2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet double2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ObjectMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ObjectMaps.java index d28ecf1..a87992f 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Double2ObjectMaps @Override public V putAndMoveToLast(double key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(double key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(double key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Double2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2ObjectOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> double2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.double2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Double2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Double2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2ObjectMap.Entry first() { return set.first(); } + public Double2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ObjectMap.Entry last() { return set.last(); } + public Double2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Double2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Double2ObjectMaps @Override public V putAndMoveToLast(double key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(double key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(double key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Double2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Double2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> double2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ShortMaps.java b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ShortMaps.java index f77709a..3416be8 100644 --- a/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ShortMaps.java +++ b/src/main/java/speiger/src/collections/doubles/utils/maps/Double2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.doubles.sets.DoubleOrderedSet; import speiger.src.collections.doubles.sets.DoubleSet; import speiger.src.collections.doubles.utils.DoubleSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Double2ShortMaps @Override public short putAndMoveToLast(double key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(double key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(double key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(double key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(double key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Double2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Double2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Double2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Double2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Double2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Double2ShortOrderedMap copy() { return map.copy(); } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.unmodifiable(map.keySet()); return (DoubleOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet double2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.double2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Double2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Double2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Double2ShortMap.Entry first() { return set.first(); } + public Double2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Double2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Double2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Double2ShortMap.Entry last() { return set.last(); } + public Double2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Double2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Double2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Double2ShortMaps @Override public short putAndMoveToLast(double key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(double key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(double key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(double key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(double key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Double2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Double2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Double2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Double2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Double2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Double2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public DoubleOrderedSet keySet() { if(keys == null) keys = DoubleSets.synchronize(map.keySet(), mutex); return (DoubleOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet double2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.double2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/collections/AbstractFloatCollection.java b/src/main/java/speiger/src/collections/floats/collections/AbstractFloatCollection.java index 67ebca1..b3a5cca 100644 --- a/src/main/java/speiger/src/collections/floats/collections/AbstractFloatCollection.java +++ b/src/main/java/speiger/src/collections/floats/collections/AbstractFloatCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.floats.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.floats.lists.FloatListIterator; import speiger.src.collections.floats.functions.FloatConsumer; import speiger.src.collections.floats.utils.FloatIterators; import speiger.src.collections.floats.utils.FloatArrays; @@ -249,4 +251,68 @@ public abstract class AbstractFloatCollection extends AbstractCollection if (a.length > size()) a[size()] = 0F; return a; } + + public static class ReverseFloatOrderedCollection extends AbstractFloatCollection implements FloatOrderedCollection { + FloatOrderedCollection collection; + Supplier reverseIterator; + + public ReverseFloatOrderedCollection(FloatOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(float o) { return collection.add(o); } + @Override + public FloatOrderedCollection reversed() { return collection; } + @Override + public void addFirst(float e) { collection.addLast(e); } + @Override + public void addLast(float e) { collection.addFirst(e); } + @Override + public boolean contains(float e) { return collection.contains(e); } + @Override + public boolean remFloat(float e) { return collection.remFloat(e); } + @Override + public void clear() { collection.clear(); } + @Override + public float getFirstFloat() { return collection.getLastFloat(); } + @Override + public float removeFirstFloat() { return collection.removeLastFloat(); } + @Override + public float getLastFloat() { return collection.getFirstFloat(); } + @Override + public float removeLastFloat() { return collection.removeFirstFloat(); } + @Override + public FloatIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements FloatListIterator { + FloatListIterator it; + + public ReverseBiIterator(FloatListIterator it) { + this.it = it; + } + + @Override + public float nextFloat() { return it.previousFloat(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public float previousFloat() { return it.nextFloat(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(float e) { it.set(e); } + @Override + public void add(float e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/floats/collections/FloatBidirectionalIterator.java b/src/main/java/speiger/src/collections/floats/collections/FloatBidirectionalIterator.java index 38aba17..4660f22 100644 --- a/src/main/java/speiger/src/collections/floats/collections/FloatBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/floats/collections/FloatBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.floats.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface FloatBidirectionalIterator extends FloatIterator, ObjectBidirectionalIterator +public interface FloatBidirectionalIterator extends FloatIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface FloatBidirectionalIterator extends FloatIterator, ObjectBidirec */ public float previousFloat(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Float previous() { return Float.valueOf(previousFloat()); diff --git a/src/main/java/speiger/src/collections/floats/collections/FloatOrderedCollection.java b/src/main/java/speiger/src/collections/floats/collections/FloatOrderedCollection.java new file mode 100644 index 0000000..40b0260 --- /dev/null +++ b/src/main/java/speiger/src/collections/floats/collections/FloatOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.floats.collections; + +public interface FloatOrderedCollection extends FloatCollection { + + FloatOrderedCollection 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(float 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(float e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public float getFirstFloat(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public float removeFirstFloat(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public float getLastFloat(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public float removeLastFloat(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/floats/lists/AbstractFloatList.java b/src/main/java/speiger/src/collections/floats/lists/AbstractFloatList.java index 6a64c29..0119b48 100644 --- a/src/main/java/speiger/src/collections/floats/lists/AbstractFloatList.java +++ b/src/main/java/speiger/src/collections/floats/lists/AbstractFloatList.java @@ -466,7 +466,6 @@ public abstract class AbstractFloatList extends AbstractFloatCollection implemen public int size() { return size; } - @Override public FloatSplititerator spliterator() { return FloatSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/floats/lists/FloatLinkedList.java b/src/main/java/speiger/src/collections/floats/lists/FloatLinkedList.java index 1cac54c..eacdf05 100644 --- a/src/main/java/speiger/src/collections/floats/lists/FloatLinkedList.java +++ b/src/main/java/speiger/src/collections/floats/lists/FloatLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.floats.functions.FloatConsumer; import speiger.src.collections.floats.utils.FloatArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.DoubleStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.floats.collections.FloatSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.floats.collections.FloatSplititerator; import speiger.src.collections.floats.utils.FloatSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class FloatLinkedList extends AbstractFloatList implements FloatPriorityD if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class FloatLinkedList extends AbstractFloatList implements FloatPriorityD * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public DoubleStream parallelPrimitiveStream() { return StreamSupport.doubleStream(new SplitIterator(this, first, 0), true); } - /** + public DoubleStream parallelPrimitiveStream() { return StreamSupport.doubleStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/floats/lists/FloatList.java b/src/main/java/speiger/src/collections/floats/lists/FloatList.java index fa9ba2e..d9a9466 100644 --- a/src/main/java/speiger/src/collections/floats/lists/FloatList.java +++ b/src/main/java/speiger/src/collections/floats/lists/FloatList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatSplititerator; import speiger.src.collections.ints.functions.consumer.IntFloatConsumer; import speiger.src.collections.floats.functions.FloatComparator; @@ -21,7 +22,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 */ -public interface FloatList extends FloatCollection, List +public interface FloatList extends FloatOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -84,6 +85,24 @@ public interface FloatList extends FloatCollection, List */ public boolean addAll(int index, FloatList 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(float 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(float e) { + add(e); + } + /** * 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. @@ -414,9 +433,9 @@ public interface FloatList extends FloatCollection, List @Override @Deprecated public default boolean add(Float e) { - return FloatCollection.super.add(e); + return FloatOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -464,7 +483,7 @@ public interface FloatList extends FloatCollection, List @Override @Deprecated public default boolean contains(Object o) { - return FloatCollection.super.contains(o); + return FloatOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -474,7 +493,7 @@ public interface FloatList extends FloatCollection, List @Override @Deprecated public default boolean remove(Object o) { - return FloatCollection.super.remove(o); + return FloatOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2BooleanMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2BooleanMap.java index 49b3646..0186901 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2BooleanMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatBooleanConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.floats.functions.function.FloatBooleanUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2BooleanMap; +import speiger.src.collections.floats.maps.interfaces.Float2BooleanOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractFloat2BooleanMap extends AbstractMap float2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2BooleanEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ByteMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ByteMap.java index b040897..0d615f1 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ByteMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatByteConsumer; import speiger.src.collections.floats.functions.function.Float2ByteFunction; import speiger.src.collections.floats.functions.function.FloatByteUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2ByteMap; +import speiger.src.collections.floats.maps.interfaces.Float2ByteOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2ByteMap extends AbstractMap implements Float2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2ByteMap extends AbstractMap imp public void putAll(Float[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedFloat2ByteOrderedMap extends AbstractFloat2ByteMap implements Float2ByteOrderedMap { + Float2ByteOrderedMap map; + + public ReversedFloat2ByteOrderedMap(Float2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(float key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(float key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(float key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(float key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(float key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(float key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(float key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Float2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(FloatByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(float key, FloatByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(float key, Float2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(float key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(float key, FloatByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(float key, FloatByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(float key, Float2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(float key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(float key, FloatByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(float key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(float key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(float key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(float key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(float key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(float key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(float key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Float2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2ByteEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2CharMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2CharMap.java index 4bff55f..8e2376e 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2CharMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatCharConsumer; import speiger.src.collections.floats.functions.function.Float2CharFunction; import speiger.src.collections.floats.functions.function.FloatCharUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2CharMap; +import speiger.src.collections.floats.maps.interfaces.Float2CharOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2CharMap extends AbstractMap implements Float2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2CharMap extends AbstractMap float2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2CharEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2DoubleMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2DoubleMap.java index dfa4b1f..8915303 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2DoubleMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatDoubleConsumer; import speiger.src.collections.floats.functions.function.Float2DoubleFunction; import speiger.src.collections.floats.functions.function.FloatDoubleUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2DoubleMap; +import speiger.src.collections.floats.maps.interfaces.Float2DoubleOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2DoubleMap extends AbstractMap implements Float2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2DoubleMap extends AbstractMap public void putAll(Float[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedFloat2DoubleOrderedMap extends AbstractFloat2DoubleMap implements Float2DoubleOrderedMap { + Float2DoubleOrderedMap map; + + public ReversedFloat2DoubleOrderedMap(Float2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(float key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(float key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(float key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(float key, double value) { return map.subFrom(key, value); } + @Override + public double remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, double value) { return map.remove(key, value); } + @Override + public double removeOrDefault(float key, double defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(float key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(float key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Float2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(FloatDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(float key, FloatDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(float key, Float2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(float key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(float key, FloatDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(float key, FloatDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(float key, Float2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(float key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(float key, FloatDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(float key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(float key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double get(float key) { return map.get(key); } + @Override + public double putAndMoveToFirst(float key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(float key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(float key, double value) { return map.putLast(key, value); } + @Override + public double putLast(float key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Float2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2DoubleEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2FloatMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2FloatMap.java index 5080405..aa6da2b 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2FloatMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatFloatConsumer; import speiger.src.collections.floats.functions.function.FloatUnaryOperator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2FloatMap; +import speiger.src.collections.floats.maps.interfaces.Float2FloatOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2FloatMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2FloatMap extends AbstractMap implements Float2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractFloat2FloatMap extends AbstractMap i public void putAll(Float[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedFloat2FloatOrderedMap extends AbstractFloat2FloatMap implements Float2FloatOrderedMap { + Float2FloatOrderedMap map; + + public ReversedFloat2FloatOrderedMap(Float2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(float key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(float key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(float key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(float key, float value) { return map.subFrom(key, value); } + @Override + public float remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(float key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(float key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(float key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Float2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(FloatFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(float key, FloatFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(float key, FloatUnaryOperator mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(float key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(float key, FloatFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(float key, FloatFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(float key, FloatUnaryOperator mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(float key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(float key, FloatFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(float key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(float key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(float key) { return map.get(key); } + @Override + public float putAndMoveToFirst(float key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(float key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(float key, float value) { return map.putLast(key, value); } + @Override + public float putLast(float key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Float2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2FloatEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2IntMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2IntMap.java index 5e409ed..419aec9 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2IntMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatIntConsumer; import speiger.src.collections.floats.functions.function.Float2IntFunction; import speiger.src.collections.floats.functions.function.FloatIntUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2IntMap; +import speiger.src.collections.floats.maps.interfaces.Float2IntOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2IntMap extends AbstractMap implements Float2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2IntMap extends AbstractMap i public void putAll(Float[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedFloat2IntOrderedMap extends AbstractFloat2IntMap implements Float2IntOrderedMap { + Float2IntOrderedMap map; + + public ReversedFloat2IntOrderedMap(Float2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(float key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(float key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(float key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(float key, int value) { return map.subFrom(key, value); } + @Override + public int remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(float key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(float key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(float key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Float2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(FloatIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(float key, FloatIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(float key, Float2IntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(float key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(float key, FloatIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(float key, FloatIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(float key, Float2IntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(float key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(float key, FloatIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(float key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(float key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(float key) { return map.get(key); } + @Override + public int putAndMoveToFirst(float key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(float key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(float key, int value) { return map.putLast(key, value); } + @Override + public int putLast(float key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Float2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2IntEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2LongMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2LongMap.java index 4207688..af73ede 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2LongMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatLongConsumer; import speiger.src.collections.floats.functions.function.Float2LongFunction; import speiger.src.collections.floats.functions.function.FloatLongUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2LongMap; +import speiger.src.collections.floats.maps.interfaces.Float2LongOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2LongMap extends AbstractMap implements Float2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2LongMap extends AbstractMap imp public void putAll(Float[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedFloat2LongOrderedMap extends AbstractFloat2LongMap implements Float2LongOrderedMap { + Float2LongOrderedMap map; + + public ReversedFloat2LongOrderedMap(Float2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(float key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(float key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(float key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(float key, long value) { return map.subFrom(key, value); } + @Override + public long remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(float key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(float key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(float key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Float2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(FloatLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(float key, FloatLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(float key, Float2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(float key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(float key, FloatLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(float key, FloatLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(float key, Float2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(float key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(float key, FloatLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(float key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(float key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(float key) { return map.get(key); } + @Override + public long putAndMoveToFirst(float key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(float key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(float key, long value) { return map.putLast(key, value); } + @Override + public long putLast(float key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Float2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2LongEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ObjectMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ObjectMap.java index 35af092..04ad401 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ObjectMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatObjectConsumer; import speiger.src.collections.floats.functions.function.FloatFunction; import speiger.src.collections.floats.functions.function.FloatObjectUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2ObjectMap; +import speiger.src.collections.floats.maps.interfaces.Float2ObjectOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractFloat2ObjectMap extends AbstractMap i public void putAll(Float[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedFloat2ObjectOrderedMap extends AbstractFloat2ObjectMap implements Float2ObjectOrderedMap { + Float2ObjectOrderedMap map; + + public ReversedFloat2ObjectOrderedMap(Float2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(float key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(float key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(float key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(float key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(float key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Float2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(FloatObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(float key, FloatObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(float key, FloatFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(float key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(float key, FloatObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(float key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(float key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(float key) { return map.get(key); } + @Override + public V putAndMoveToFirst(float key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(float key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(float key, V value) { return map.putLast(key, value); } + @Override + public V putLast(float key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Float2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> float2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2ObjectEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ShortMap.java b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ShortMap.java index 0ea44ce..9cc4fa1 100644 --- a/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ShortMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/abstracts/AbstractFloat2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.floats.functions.consumer.FloatShortConsumer; import speiger.src.collections.floats.functions.function.Float2ShortFunction; import speiger.src.collections.floats.functions.function.FloatShortUnaryOperator; import speiger.src.collections.floats.maps.interfaces.Float2ShortMap; +import speiger.src.collections.floats.maps.interfaces.Float2ShortOrderedMap; +import speiger.src.collections.floats.sets.FloatOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.maps.Float2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractFloat2ShortMap extends AbstractMap implements Float2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractFloat2ShortMap extends AbstractMap i public void putAll(Float[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedFloat2ShortOrderedMap extends AbstractFloat2ShortMap implements Float2ShortOrderedMap { + Float2ShortOrderedMap map; + + public ReversedFloat2ShortOrderedMap(Float2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractFloat2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Float2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(float key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(float key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(float key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(float key, short value) { return map.subFrom(key, value); } + @Override + public short remove(float key) { return map.remove(key); } + @Override + public boolean remove(float key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(float key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(float key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(float key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(float key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Float2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(FloatShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(float key, FloatShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(float key, Float2ShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(float key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(float key, FloatShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(float key, FloatShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(float key, Float2ShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(float key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(float key, FloatShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(float key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(float key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(float key) { return map.get(key); } + @Override + public short putAndMoveToFirst(float key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(float key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(float key, short value) { return map.putLast(key, value); } + @Override + public short putLast(float key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(float key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(float key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(float key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(float key) { return map.getAndMoveToFirst(key); } + @Override + public float firstFloatKey() { return map.lastFloatKey(); } + @Override + public float pollFirstFloatKey() { return map.pollLastFloatKey(); } + @Override + public float lastFloatKey() { return map.firstFloatKey(); } + @Override + public float pollLastFloatKey() { return map.pollFirstFloatKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Float2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Float2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Float2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Float2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet float2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.float2ShortEntrySet()); } + @Override + public FloatOrderedSet keySet() { return new AbstractFloatSet.ReversedFloatOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Float2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2BooleanLinkedOpenCustomHashMap.java index ff4c637..85c3086 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto return getDefaultReturnValue(); } + @Override + public boolean putFirst(float key, boolean value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 boolean putLast(float key, boolean value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto return values[lastIndex]; } + @Override + public Float2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } @Override - public Float2BooleanMap.Entry first() { + public Float2BooleanMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstBooleanValue()); } @Override - public Float2BooleanMap.Entry last() { + public Float2BooleanMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastBooleanValue()); } @Override - public Float2BooleanMap.Entry pollFirst() { + public Float2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstBooleanValue()); pollFirstFloatKey(); return entry; } @Override - public Float2BooleanMap.Entry pollLast() { + public Float2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastBooleanValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstFloatKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Float2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2BooleanLinkedOpenCustomHashMap extends Float2BooleanOpenCusto public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ByteLinkedOpenCustomHashMap.java index 9a08ecf..8d30bd7 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ByteLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -258,6 +258,54 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM return getDefaultReturnValue(); } + @Override + public byte putFirst(float key, byte value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 byte putLast(float key, byte value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM return values[lastIndex]; } + @Override + public Float2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } @Override - public Float2ByteMap.Entry first() { + public Float2ByteMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstByteValue()); } @Override - public Float2ByteMap.Entry last() { + public Float2ByteMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastByteValue()); } @Override - public Float2ByteMap.Entry pollFirst() { + public Float2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstByteValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ByteMap.Entry pollLast() { + public Float2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastByteValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstFloatKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Float2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1284,16 +1399,20 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2ByteLinkedOpenCustomHashMap extends Float2ByteOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2CharLinkedOpenCustomHashMap.java index 73ba0af..a4c58a4 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2CharLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -258,6 +258,54 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM return getDefaultReturnValue(); } + @Override + public char putFirst(float key, char value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 char putLast(float key, char value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM return values[lastIndex]; } + @Override + public Float2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } @Override - public Float2CharMap.Entry first() { + public Float2CharMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstCharValue()); } @Override - public Float2CharMap.Entry last() { + public Float2CharMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastCharValue()); } @Override - public Float2CharMap.Entry pollFirst() { + public Float2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstCharValue()); pollFirstFloatKey(); return entry; } @Override - public Float2CharMap.Entry pollLast() { + public Float2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastCharValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstFloatKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Float2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1284,16 +1399,20 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2CharLinkedOpenCustomHashMap extends Float2CharOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2DoubleLinkedOpenCustomHashMap.java index dd5e259..717f9ac 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2DoubleLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -258,6 +258,54 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH return getDefaultReturnValue(); } + @Override + public double putFirst(float key, double value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 double putLast(float key, double value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH return values[lastIndex]; } + @Override + public Float2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } @Override - public Float2DoubleMap.Entry first() { + public Float2DoubleMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstDoubleValue()); } @Override - public Float2DoubleMap.Entry last() { + public Float2DoubleMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastDoubleValue()); } @Override - public Float2DoubleMap.Entry pollFirst() { + public Float2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstDoubleValue()); pollFirstFloatKey(); return entry; } @Override - public Float2DoubleMap.Entry pollLast() { + public Float2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastDoubleValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstFloatKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Float2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1284,16 +1399,20 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2DoubleLinkedOpenCustomHashMap extends Float2DoubleOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2FloatLinkedOpenCustomHashMap.java index cadccc1..5db9928 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2FloatLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas return getDefaultReturnValue(); } + @Override + public float putFirst(float key, float value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 float putLast(float key, float value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -386,6 +434,52 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas return values[lastIndex]; } + @Override + public Float2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } @Override - public Float2FloatMap.Entry first() { + public Float2FloatMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstFloatValue()); } @Override - public Float2FloatMap.Entry last() { + public Float2FloatMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastFloatValue()); } @Override - public Float2FloatMap.Entry pollFirst() { + public Float2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstFloatValue()); pollFirstFloatKey(); return entry; } @Override - public Float2FloatMap.Entry pollLast() { + public Float2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastFloatValue()); pollLastFloatKey(); return entry; @@ -611,7 +705,12 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1023,30 +1127,41 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstFloatKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Float2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastFloatKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1204,7 +1319,7 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1234,7 +1349,7 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1256,7 +1371,7 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1277,16 +1392,20 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Float2FloatLinkedOpenCustomHashMap extends Float2FloatOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2IntLinkedOpenCustomHashMap.java index 02ccdac..85131f9 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public int putFirst(float key, int value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 int putLast(float key, int value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap return values[lastIndex]; } + @Override + public Float2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } @Override - public Float2IntMap.Entry first() { + public Float2IntMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstIntValue()); } @Override - public Float2IntMap.Entry last() { + public Float2IntMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastIntValue()); } @Override - public Float2IntMap.Entry pollFirst() { + public Float2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstIntValue()); pollFirstFloatKey(); return entry; } @Override - public Float2IntMap.Entry pollLast() { + public Float2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastIntValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstFloatKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Float2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2IntLinkedOpenCustomHashMap extends Float2IntOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2LongLinkedOpenCustomHashMap.java index d6ca170..9913ec3 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2LongLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -258,6 +258,54 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM return getDefaultReturnValue(); } + @Override + public long putFirst(float key, long value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 long putLast(float key, long value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM return values[lastIndex]; } + @Override + public Float2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } @Override - public Float2LongMap.Entry first() { + public Float2LongMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstLongValue()); } @Override - public Float2LongMap.Entry last() { + public Float2LongMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastLongValue()); } @Override - public Float2LongMap.Entry pollFirst() { + public Float2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstLongValue()); pollFirstFloatKey(); return entry; } @Override - public Float2LongMap.Entry pollLast() { + public Float2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastLongValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstFloatKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Float2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1284,16 +1399,20 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2LongLinkedOpenCustomHashMap extends Float2LongOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ObjectLinkedOpenCustomHashMap.java index 8cf4d96..751d00c 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust return getDefaultReturnValue(); } + @Override + public V putFirst(float key, V value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 V putLast(float key, V value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -388,6 +436,52 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust return values[lastIndex]; } + @Override + public Float2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> float2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } @Override - public Float2ObjectMap.Entry first() { + public Float2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstFloatKey(), firstValue()); } @Override - public Float2ObjectMap.Entry last() { + public Float2ObjectMap.Entry getLast() { return new BasicEntry<>(lastFloatKey(), lastValue()); } @Override - public Float2ObjectMap.Entry pollFirst() { + public Float2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstFloatKey(), firstValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ObjectMap.Entry pollLast() { + public Float2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastFloatKey(), lastValue()); pollLastFloatKey(); return entry; @@ -613,7 +707,12 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,31 +1129,42 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Float2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Float2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Float2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstFloatKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastFloatKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Float2ObjectLinkedOpenCustomHashMap extends Float2ObjectOpenCust public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ShortLinkedOpenCustomHashMap.java index e145dc8..e0ec186 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/customHash/Float2ShortLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.utils.FloatStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -258,6 +258,54 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas return getDefaultReturnValue(); } + @Override + public short putFirst(float key, short value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + 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 short putLast(float key, short value) { + if(strategy.equals(key, 0F)) { + 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], 0F)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || strategy.equals(firstFloatKey(), key)) return false; @@ -393,6 +441,52 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas return values[lastIndex]; } + @Override + public Float2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getFloatKey(), 0F)) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } @Override - public Float2ShortMap.Entry first() { + public Float2ShortMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstShortValue()); } @Override - public Float2ShortMap.Entry last() { + public Float2ShortMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastShortValue()); } @Override - public Float2ShortMap.Entry pollFirst() { + public Float2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstShortValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ShortMap.Entry pollLast() { + public Float2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastShortValue()); pollLastFloatKey(); return entry; @@ -618,7 +712,12 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1030,30 +1134,41 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Float2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Float2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstFloatKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Float2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Float2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastFloatKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1211,7 +1326,7 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1241,7 +1356,7 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1263,7 +1378,7 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1284,16 +1399,20 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Float2ShortLinkedOpenCustomHashMap extends Float2ShortOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2BooleanLinkedOpenHashMap.java index 95e2807..3f81e58 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2BooleanOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp return getDefaultReturnValue(); } + @Override + public boolean putFirst(float key, boolean value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 boolean putLast(float key, boolean value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp return values[lastIndex]; } + @Override + public Float2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } @Override - public Float2BooleanMap.Entry first() { + public Float2BooleanMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstBooleanValue()); } @Override - public Float2BooleanMap.Entry last() { + public Float2BooleanMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastBooleanValue()); } @Override - public Float2BooleanMap.Entry pollFirst() { + public Float2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstBooleanValue()); pollFirstFloatKey(); return entry; } @Override - public Float2BooleanMap.Entry pollLast() { + public Float2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastBooleanValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Float2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstFloatKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2BooleanLinkedOpenHashMap extends Float2BooleanOpenHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ByteLinkedOpenHashMap.java index 7ece834..23dbc14 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ByteLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ByteOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -235,6 +235,54 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement return getDefaultReturnValue(); } + @Override + public byte putFirst(float key, byte value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 byte putLast(float key, byte value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement return values[lastIndex]; } + @Override + public Float2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } @Override - public Float2ByteMap.Entry first() { + public Float2ByteMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstByteValue()); } @Override - public Float2ByteMap.Entry last() { + public Float2ByteMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastByteValue()); } @Override - public Float2ByteMap.Entry pollFirst() { + public Float2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstByteValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ByteMap.Entry pollLast() { + public Float2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastByteValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Float2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstFloatKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1279,13 +1394,16 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2ByteLinkedOpenHashMap extends Float2ByteOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2CharLinkedOpenHashMap.java index 3ba72e2..44040ff 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2CharLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2CharOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -235,6 +235,54 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement return getDefaultReturnValue(); } + @Override + public char putFirst(float key, char value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 char putLast(float key, char value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement return values[lastIndex]; } + @Override + public Float2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } @Override - public Float2CharMap.Entry first() { + public Float2CharMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstCharValue()); } @Override - public Float2CharMap.Entry last() { + public Float2CharMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastCharValue()); } @Override - public Float2CharMap.Entry pollFirst() { + public Float2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstCharValue()); pollFirstFloatKey(); return entry; } @Override - public Float2CharMap.Entry pollLast() { + public Float2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastCharValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2CharLinkedOpenHashMap.this.clear(); + public void clear() { Float2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstFloatKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1279,13 +1394,16 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2CharLinkedOpenHashMap extends Float2CharOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2DoubleLinkedOpenHashMap.java index f8720c7..aeff47d 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2DoubleLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2DoubleOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -235,6 +235,54 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple return getDefaultReturnValue(); } + @Override + public double putFirst(float key, double value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 double putLast(float key, double value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple return values[lastIndex]; } + @Override + public Float2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } @Override - public Float2DoubleMap.Entry first() { + public Float2DoubleMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstDoubleValue()); } @Override - public Float2DoubleMap.Entry last() { + public Float2DoubleMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastDoubleValue()); } @Override - public Float2DoubleMap.Entry pollFirst() { + public Float2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstDoubleValue()); pollFirstFloatKey(); return entry; } @Override - public Float2DoubleMap.Entry pollLast() { + public Float2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastDoubleValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Float2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstFloatKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1279,13 +1394,16 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2DoubleLinkedOpenHashMap extends Float2DoubleOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2FloatLinkedOpenHashMap.java index 9ead274..7ddb1af 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2FloatLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2FloatOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public float putFirst(float key, float value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 float putLast(float key, float value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -384,6 +432,52 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme return values[lastIndex]; } + @Override + public Float2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } @Override - public Float2FloatMap.Entry first() { + public Float2FloatMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstFloatValue()); } @Override - public Float2FloatMap.Entry last() { + public Float2FloatMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastFloatValue()); } @Override - public Float2FloatMap.Entry pollFirst() { + public Float2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstFloatValue()); pollFirstFloatKey(); return entry; } @Override - public Float2FloatMap.Entry pollLast() { + public Float2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastFloatValue()); pollLastFloatKey(); return entry; @@ -609,7 +703,12 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1018,32 +1122,43 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Float2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstFloatKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1200,7 +1315,7 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1230,7 +1345,7 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1252,7 +1367,7 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1272,13 +1387,16 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1309,11 +1427,11 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Float2FloatLinkedOpenHashMap extends Float2FloatOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2IntLinkedOpenHashMap.java index eb48e97..9ec803b 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2IntOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements return getDefaultReturnValue(); } + @Override + public int putFirst(float key, int value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 int putLast(float key, int value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements return values[lastIndex]; } + @Override + public Float2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } @Override - public Float2IntMap.Entry first() { + public Float2IntMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstIntValue()); } @Override - public Float2IntMap.Entry last() { + public Float2IntMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastIntValue()); } @Override - public Float2IntMap.Entry pollFirst() { + public Float2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstIntValue()); pollFirstFloatKey(); return entry; } @Override - public Float2IntMap.Entry pollLast() { + public Float2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastIntValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2IntLinkedOpenHashMap.this.clear(); + public void clear() { Float2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstFloatKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2IntLinkedOpenHashMap extends Float2IntOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2LongLinkedOpenHashMap.java index ad24ff7..3caffdc 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2LongLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2LongOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -235,6 +235,54 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement return getDefaultReturnValue(); } + @Override + public long putFirst(float key, long value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 long putLast(float key, long value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement return values[lastIndex]; } + @Override + public Float2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } @Override - public Float2LongMap.Entry first() { + public Float2LongMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstLongValue()); } @Override - public Float2LongMap.Entry last() { + public Float2LongMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastLongValue()); } @Override - public Float2LongMap.Entry pollFirst() { + public Float2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstLongValue()); pollFirstFloatKey(); return entry; } @Override - public Float2LongMap.Entry pollLast() { + public Float2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastLongValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2LongLinkedOpenHashMap.this.clear(); + public void clear() { Float2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstFloatKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1279,13 +1394,16 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2LongLinkedOpenHashMap extends Float2LongOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ObjectLinkedOpenHashMap.java index e9c31dc..a241f51 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ObjectOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap return getDefaultReturnValue(); } + @Override + public V putFirst(float key, V value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 V putLast(float key, V value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -375,6 +423,52 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap return values[lastIndex]; } + @Override + public Float2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> float2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } @Override - public Float2ObjectMap.Entry first() { + public Float2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstFloatKey(), firstValue()); } @Override - public Float2ObjectMap.Entry last() { + public Float2ObjectMap.Entry getLast() { return new BasicEntry<>(lastFloatKey(), lastValue()); } @Override - public Float2ObjectMap.Entry pollFirst() { + public Float2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstFloatKey(), firstValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ObjectMap.Entry pollLast() { + public Float2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastFloatKey(), lastValue()); pollLastFloatKey(); return entry; @@ -600,7 +694,12 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1009,33 +1113,44 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Float2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstFloatKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1192,7 +1307,7 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1222,7 +1337,7 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1244,7 +1359,7 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1301,11 +1419,11 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Float2ObjectLinkedOpenHashMap extends Float2ObjectOpenHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ShortLinkedOpenHashMap.java index d1cead9..671c155 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/hash/Float2ShortLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ShortOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -235,6 +235,54 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public short putFirst(float key, short value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(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 short putLast(float key, short value) { + if(Float.floatToIntBits(key) == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Float.hashCode(key)) & mask; + while(Float.floatToIntBits(key) == 0) { + if(Float.floatToIntBits(keys[pos]) == Float.floatToIntBits(key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(float key) { if(isEmpty() || Float.floatToIntBits(firstFloatKey()) == Float.floatToIntBits(key)) return false; @@ -391,6 +439,52 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme return values[lastIndex]; } + @Override + public Float2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Float2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(Float.floatToIntBits(result.getFloatKey()) == 0) { + containsNull = false; + keys[nullIndex] = 0F; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet float2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } @Override - public Float2ShortMap.Entry first() { + public Float2ShortMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstShortValue()); } @Override - public Float2ShortMap.Entry last() { + public Float2ShortMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastShortValue()); } @Override - public Float2ShortMap.Entry pollFirst() { + public Float2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstShortValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ShortMap.Entry pollLast() { + public Float2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastShortValue()); pollLastFloatKey(); return entry; @@ -616,7 +710,12 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { + public float removeLastFloat() { return pollLastFloatKey(); } @@ -1025,32 +1129,43 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Float2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Float2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Float2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstFloatKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1207,7 +1322,7 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1237,7 +1352,7 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1259,7 +1374,7 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1279,13 +1394,16 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1316,11 +1434,11 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Float2ShortLinkedOpenHashMap extends Float2ShortOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2BooleanOpenHashMap.java index 2c22869..3888a59 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap @Override public boolean putAndMoveToLast(float key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(float key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(float key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap public boolean moveToLast(Float2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2BooleanMap.Entry first() { + public Float2BooleanMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstBooleanValue()); } @Override - public Float2BooleanMap.Entry last() { + public Float2BooleanMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastBooleanValue()); } @Override - public Float2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1211,11 +1250,11 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableFloat2BooleanOpenHashMap extends AbstractFloat2BooleanMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ByteOpenHashMap.java index 3667992..f946b64 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ByteOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem @Override public byte putAndMoveToLast(float key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(float key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(float key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2ByteEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem public boolean moveToLast(Float2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2ByteMap.Entry first() { + public Float2ByteMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstByteValue()); } @Override - public Float2ByteMap.Entry last() { + public Float2ByteMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastByteValue()); } @Override - public Float2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2ByteOpenHashMap extends AbstractFloat2ByteMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2CharOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2CharOpenHashMap.java index b979575..3101fbe 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2CharOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem @Override public char putAndMoveToLast(float key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(float key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(float key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2CharEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem public boolean moveToLast(Float2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2CharMap.Entry first() { + public Float2CharMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstCharValue()); } @Override - public Float2CharMap.Entry last() { + public Float2CharMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastCharValue()); } @Override - public Float2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2CharOpenHashMap extends AbstractFloat2CharMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2DoubleOpenHashMap.java index 0da6c77..2a397b0 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2DoubleOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im @Override public double putAndMoveToLast(float key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(float key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(float key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2DoubleEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im public boolean moveToLast(Float2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2DoubleMap.Entry first() { + public Float2DoubleMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstDoubleValue()); } @Override - public Float2DoubleMap.Entry last() { + public Float2DoubleMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastDoubleValue()); } @Override - public Float2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2DoubleOpenHashMap extends AbstractFloat2DoubleMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2FloatOpenHashMap.java index c6d3e74..10ba231 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2FloatOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.floats.utils.FloatArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl @Override public float putAndMoveToLast(float key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(float key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(float key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2FloatEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl public boolean moveToLast(Float2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2FloatMap.Entry first() { + public Float2FloatMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstFloatValue()); } @Override - public Float2FloatMap.Entry last() { + public Float2FloatMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastFloatValue()); } @Override - public Float2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1170,13 +1206,16 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1207,11 +1246,11 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableFloat2FloatOpenHashMap extends AbstractFloat2FloatMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2IntOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2IntOpenHashMap.java index 6e65c50..ec0fcd9 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen @Override public int putAndMoveToLast(float key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(float key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(float key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen public boolean moveToLast(Float2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2IntMap.Entry first() { + public Float2IntMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstIntValue()); } @Override - public Float2IntMap.Entry last() { + public Float2IntMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastIntValue()); } @Override - public Float2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2IntOpenHashMap extends AbstractFloat2IntMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2LongOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2LongOpenHashMap.java index 38713bc..7934222 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2LongOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem @Override public long putAndMoveToLast(float key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(float key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(float key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2LongEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem public boolean moveToLast(Float2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2LongMap.Entry first() { + public Float2LongMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstLongValue()); } @Override - public Float2LongMap.Entry last() { + public Float2LongMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastLongValue()); } @Override - public Float2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2LongOpenHashMap extends AbstractFloat2LongMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ObjectOpenHashMap.java index 33524a9..37ad108 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient ObjectCollection valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap @Override public V putAndMoveToLast(float key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(float key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(float key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -344,7 +348,24 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap public V lastValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> float2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap public boolean moveToLast(Float2ObjectMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2ObjectMap.Entry first() { + public Float2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstFloatKey(), firstValue()); } @Override - public Float2ObjectMap.Entry last() { + public Float2ObjectMap.Entry getLast() { return new BasicEntry<>(lastFloatKey(), lastValue()); } @Override - public Float2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -902,31 +933,36 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1130,7 +1166,7 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1188,11 +1227,11 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1209,20 +1248,30 @@ public class ImmutableFloat2ObjectOpenHashMap extends AbstractFloat2ObjectMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ShortOpenHashMap.java index e7bc266..913488a 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/immutable/ImmutableFloat2ShortOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl /** KeySet cache */ protected transient FloatOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl @Override public short putAndMoveToLast(float key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(float key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(float key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Float2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Float2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Float2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet float2ShortEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl public boolean moveToLast(Float2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Float2ShortMap.Entry first() { + public Float2ShortMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstShortValue()); } @Override - public Float2ShortMap.Entry last() { + public Float2ShortMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastShortValue()); } @Override - public Float2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl @Override public FloatListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public float firstFloat() { + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableFloat2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableFloat2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(float from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(float from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(float from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1179,13 +1215,16 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(float from) { @@ -1216,11 +1255,11 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableFloat2ShortOpenHashMap extends AbstractFloat2ShortMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2BooleanArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2BooleanArrayMap.java index f5c1ef5..361ced7 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2BooleanOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F return lastValue; } + @Override + public boolean putFirst(float key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(float key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F return result; } + @Override + public Float2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(float key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } @Override - public Float2BooleanMap.Entry first() { + public Float2BooleanMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstBooleanValue()); } @Override - public Float2BooleanMap.Entry last() { + public Float2BooleanMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastBooleanValue()); } @Override - public Float2BooleanMap.Entry pollFirst() { + public Float2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstBooleanValue()); pollFirstFloatKey(); return entry; } @Override - public Float2BooleanMap.Entry pollLast() { + public Float2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastBooleanValue()); pollLastFloatKey(); return entry; @@ -720,7 +769,12 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F @Override public boolean moveToLast(float o) { return Float2BooleanArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F @Override public void clear() { Float2BooleanArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2BooleanArrayMap.this.size(); - } - + public int size() { return Float2BooleanArrayMap.this.size(); } @Override - public void clear() { - Float2BooleanArrayMap.this.clear(); + public void clear() { Float2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstFloatKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1233,6 +1292,9 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Float2BooleanArrayMap extends AbstractFloat2BooleanMap implements F public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ByteArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ByteArrayMap.java index 8071e26..43212fe 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ByteArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ByteOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -63,7 +63,7 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B return lastValue; } + @Override + public byte putFirst(float key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(float key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B return result; } + @Override + public Float2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } @Override - public Float2ByteMap.Entry first() { + public Float2ByteMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstByteValue()); } @Override - public Float2ByteMap.Entry last() { + public Float2ByteMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastByteValue()); } @Override - public Float2ByteMap.Entry pollFirst() { + public Float2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstByteValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ByteMap.Entry pollLast() { + public Float2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastByteValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B @Override public boolean moveToLast(float o) { return Float2ByteArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B @Override public void clear() { Float2ByteArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ByteArrayMap.this.size(); - } - + public int size() { return Float2ByteArrayMap.this.size(); } @Override - public void clear() { - Float2ByteArrayMap.this.clear(); + public void clear() { Float2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstFloatKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2ByteMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2ByteMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2ByteArrayMap extends AbstractFloat2ByteMap implements Float2B public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2CharArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2CharArrayMap.java index 6beed7b..f4d1d27 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2CharArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2CharOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -63,7 +63,7 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C return lastValue; } + @Override + public char putFirst(float key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(float key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C return result; } + @Override + public Float2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } @Override - public Float2CharMap.Entry first() { + public Float2CharMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstCharValue()); } @Override - public Float2CharMap.Entry last() { + public Float2CharMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastCharValue()); } @Override - public Float2CharMap.Entry pollFirst() { + public Float2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstCharValue()); pollFirstFloatKey(); return entry; } @Override - public Float2CharMap.Entry pollLast() { + public Float2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastCharValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C @Override public boolean moveToLast(float o) { return Float2CharArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C @Override public void clear() { Float2CharArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2CharArrayMap.this.size(); - } - + public int size() { return Float2CharArrayMap.this.size(); } @Override - public void clear() { - Float2CharArrayMap.this.clear(); + public void clear() { Float2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstFloatKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2CharMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2CharMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2CharArrayMap extends AbstractFloat2CharMap implements Float2C public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2DoubleArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2DoubleArrayMap.java index b020305..c1b41db 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2DoubleArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2DoubleOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -63,7 +63,7 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo return lastValue; } + @Override + public double putFirst(float key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(float key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo return result; } + @Override + public Float2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } @Override - public Float2DoubleMap.Entry first() { + public Float2DoubleMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstDoubleValue()); } @Override - public Float2DoubleMap.Entry last() { + public Float2DoubleMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastDoubleValue()); } @Override - public Float2DoubleMap.Entry pollFirst() { + public Float2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstDoubleValue()); pollFirstFloatKey(); return entry; } @Override - public Float2DoubleMap.Entry pollLast() { + public Float2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastDoubleValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo @Override public boolean moveToLast(float o) { return Float2DoubleArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo @Override public void clear() { Float2DoubleArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2DoubleArrayMap.this.size(); - } - + public int size() { return Float2DoubleArrayMap.this.size(); } @Override - public void clear() { - Float2DoubleArrayMap.this.clear(); + public void clear() { Float2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstFloatKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2DoubleMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2DoubleMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2DoubleArrayMap extends AbstractFloat2DoubleMap implements Flo public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2FloatArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2FloatArrayMap.java index 65aef8c..d9a834e 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2FloatArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2FloatOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float return lastValue; } + @Override + public float putFirst(float key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(float key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float return result; } + @Override + public Float2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(float key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } @Override - public Float2FloatMap.Entry first() { + public Float2FloatMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstFloatValue()); } @Override - public Float2FloatMap.Entry last() { + public Float2FloatMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastFloatValue()); } @Override - public Float2FloatMap.Entry pollFirst() { + public Float2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstFloatValue()); pollFirstFloatKey(); return entry; } @Override - public Float2FloatMap.Entry pollLast() { + public Float2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastFloatValue()); pollLastFloatKey(); return entry; @@ -736,7 +785,12 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float @Override public boolean moveToLast(float o) { return Float2FloatArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float @Override public void clear() { Float2FloatArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2FloatArrayMap.this.size(); - } - + public int size() { return Float2FloatArrayMap.this.size(); } @Override - public void clear() { - Float2FloatArrayMap.this.clear(); + public void clear() { Float2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstFloatKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2FloatMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2FloatMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1249,6 +1308,9 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Float2FloatArrayMap extends AbstractFloat2FloatMap implements Float public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2IntArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2IntArrayMap.java index c376196..1bea7eb 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2IntOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int return lastValue; } + @Override + public int putFirst(float key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(float key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int return result; } + @Override + public Float2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } @Override - public Float2IntMap.Entry first() { + public Float2IntMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstIntValue()); } @Override - public Float2IntMap.Entry last() { + public Float2IntMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastIntValue()); } @Override - public Float2IntMap.Entry pollFirst() { + public Float2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstIntValue()); pollFirstFloatKey(); return entry; } @Override - public Float2IntMap.Entry pollLast() { + public Float2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastIntValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int @Override public boolean moveToLast(float o) { return Float2IntArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int @Override public void clear() { Float2IntArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2IntArrayMap.this.size(); - } - + public int size() { return Float2IntArrayMap.this.size(); } @Override - public void clear() { - Float2IntArrayMap.this.clear(); + public void clear() { Float2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstFloatKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2IntArrayMap extends AbstractFloat2IntMap implements Float2Int public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2LongArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2LongArrayMap.java index ecdcaa2..3d001e8 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2LongArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2LongOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -63,7 +63,7 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L return lastValue; } + @Override + public long putFirst(float key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(float key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L return result; } + @Override + public Float2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } @Override - public Float2LongMap.Entry first() { + public Float2LongMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstLongValue()); } @Override - public Float2LongMap.Entry last() { + public Float2LongMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastLongValue()); } @Override - public Float2LongMap.Entry pollFirst() { + public Float2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstLongValue()); pollFirstFloatKey(); return entry; } @Override - public Float2LongMap.Entry pollLast() { + public Float2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastLongValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L @Override public boolean moveToLast(float o) { return Float2LongArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L @Override public void clear() { Float2LongArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2LongArrayMap.this.size(); - } - + public int size() { return Float2LongArrayMap.this.size(); } @Override - public void clear() { - Float2LongArrayMap.this.clear(); + public void clear() { Float2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstFloatKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2LongMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2LongMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2LongArrayMap extends AbstractFloat2LongMap implements Float2L public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ObjectArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ObjectArrayMap.java index 1026f62..7d25e1f 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ObjectOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen return lastValue; } + @Override + public V putFirst(float key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(float key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen return result; } + @Override + public Float2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Float2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Float2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(float key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } @Override - public Float2ObjectMap.Entry first() { + public Float2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstFloatKey(), firstValue()); } @Override - public Float2ObjectMap.Entry last() { + public Float2ObjectMap.Entry getLast() { return new BasicEntry<>(lastFloatKey(), lastValue()); } @Override - public Float2ObjectMap.Entry pollFirst() { + public Float2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstFloatKey(), firstValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ObjectMap.Entry pollLast() { + public Float2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastFloatKey(), lastValue()); pollLastFloatKey(); return entry; @@ -656,7 +705,12 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen @Override public boolean moveToLast(float o) { return Float2ObjectArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen @Override public void clear() { Float2ObjectArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ObjectArrayMap.this.size(); - } - + public int size() { return Float2ObjectArrayMap.this.size(); } @Override - public void clear() { - Float2ObjectArrayMap.this.clear(); + public void clear() { Float2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstFloatKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1169,6 +1228,9 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ShortArrayMap.java b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ShortArrayMap.java index 1ce6913..6f3e4ce 100644 --- a/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/impl/misc/Float2ShortArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.floats.maps.interfaces.Float2ShortOrderedMap; import speiger.src.collections.floats.sets.AbstractFloatSet; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -63,7 +63,7 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float /** KeySet cache */ protected FloatOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float return lastValue; } + @Override + public short putFirst(float key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(float key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(float key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float return result; } + @Override + public Float2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Float2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Float2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Float2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(float key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } @Override - public Float2ShortMap.Entry first() { + public Float2ShortMap.Entry getFirst() { return new BasicEntry(firstFloatKey(), firstShortValue()); } @Override - public Float2ShortMap.Entry last() { + public Float2ShortMap.Entry getLast() { return new BasicEntry(lastFloatKey(), lastShortValue()); } @Override - public Float2ShortMap.Entry pollFirst() { + public Float2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstFloatKey(), firstShortValue()); pollFirstFloatKey(); return entry; } @Override - public Float2ShortMap.Entry pollLast() { + public Float2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastFloatKey(), lastShortValue()); pollLastFloatKey(); return entry; @@ -743,7 +792,12 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float @Override public boolean moveToLast(float o) { return Float2ShortArrayMap.this.moveToLast(o); } @Override - public FloatListIterator iterator() { return new KeyIterator(); } + public FloatListIterator iterator() { return new KeyIterator(true); } + @Override + public FloatListIterator reverseIterator() { return new KeyIterator(false); } @Override public FloatBidirectionalIterator iterator(float fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float @Override public void clear() { Float2ShortArrayMap.this.clear(); } @Override - public float firstFloat() { return firstFloatKey(); } + public float getFirstFloat() { return firstFloatKey(); } @Override - public float pollFirstFloat() { return pollFirstFloatKey(); } + public float removeFirstFloat() { return pollFirstFloatKey(); } @Override - public float lastFloat() { return lastFloatKey(); } + public float getLastFloat() { return lastFloatKey(); } @Override - public float pollLastFloat() { return pollLastFloatKey(); } + public float removeLastFloat() { return pollLastFloatKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Float2ShortArrayMap.this.size(); - } - + public int size() { return Float2ShortArrayMap.this.size(); } @Override - public void clear() { - Float2ShortArrayMap.this.clear(); + public void clear() { Float2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstFloatKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastFloatKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(float from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(float element) { super(element); } @Override public Float2ShortMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(float from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(float element) { super(element); } @Override public Float2ShortMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } private class KeyIterator extends MapIterator implements FloatListIterator { - public KeyIterator() {} - public KeyIterator(float element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(float element) { super(element); } @Override public float previousFloat() { @@ -1256,6 +1315,9 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(float element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(float element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Float2ShortArrayMap extends AbstractFloat2ShortMap implements Float public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanMap.java index 8c515f8..4fc6c1b 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanMap.java @@ -94,7 +94,7 @@ public interface Float2BooleanMap extends Map, FloatPredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanOrderedMap.java index 3617f59..4b507da 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2BooleanMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2BooleanOrderedMap extends Float2BooleanMap */ public boolean putAndMoveToLast(float key, boolean 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 boolean putFirst(float key, boolean 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 boolean putLast(float key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2BooleanOrderedMap extends Float2BooleanMap */ public boolean lastBooleanValue(); + + public Float2BooleanMap.Entry firstEntry(); + + public Float2BooleanMap.Entry lastEntry(); + + public Float2BooleanMap.Entry pollFirstEntry(); + + public Float2BooleanMap.Entry pollLastEntry(); @Override public Float2BooleanOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet float2BooleanEntrySet(); + public default Float2BooleanOrderedMap reversed() { return new AbstractFloat2BooleanMap.ReversedFloat2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteMap.java index ea55003..0ac8d3b 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteMap.java @@ -94,7 +94,7 @@ public interface Float2ByteMap extends Map, Float2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteOrderedMap.java index 4c27638..cdf1ab7 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2ByteMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2ByteOrderedMap extends Float2ByteMap */ public byte putAndMoveToLast(float key, byte 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 byte putFirst(float key, byte 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 byte putLast(float key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2ByteOrderedMap extends Float2ByteMap */ public byte lastByteValue(); + + public Float2ByteMap.Entry firstEntry(); + + public Float2ByteMap.Entry lastEntry(); + + public Float2ByteMap.Entry pollFirstEntry(); + + public Float2ByteMap.Entry pollLastEntry(); @Override public Float2ByteOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet float2ByteEntrySet(); + public default Float2ByteOrderedMap reversed() { return new AbstractFloat2ByteMap.ReversedFloat2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharMap.java index 711df79..dfd3842 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharMap.java @@ -94,7 +94,7 @@ public interface Float2CharMap extends Map, Float2CharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharOrderedMap.java index a1d9fc5..4785ea3 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2CharMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2CharOrderedMap extends Float2CharMap */ public char putAndMoveToLast(float key, char 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 char putFirst(float key, char 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 char putLast(float key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2CharOrderedMap extends Float2CharMap */ public char lastCharValue(); + + public Float2CharMap.Entry firstEntry(); + + public Float2CharMap.Entry lastEntry(); + + public Float2CharMap.Entry pollFirstEntry(); + + public Float2CharMap.Entry pollLastEntry(); @Override public Float2CharOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet float2CharEntrySet(); + public default Float2CharOrderedMap reversed() { return new AbstractFloat2CharMap.ReversedFloat2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleMap.java index ccaa4ce..318be8e 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleMap.java @@ -94,7 +94,7 @@ public interface Float2DoubleMap extends Map, Float2DoubleFunctio * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleOrderedMap.java index 7f9bdfb..0649d3e 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2DoubleMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2DoubleOrderedMap extends Float2DoubleMap */ public double putAndMoveToLast(float key, double 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 double putFirst(float key, double 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 double putLast(float key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2DoubleOrderedMap extends Float2DoubleMap */ public double lastDoubleValue(); + + public Float2DoubleMap.Entry firstEntry(); + + public Float2DoubleMap.Entry lastEntry(); + + public Float2DoubleMap.Entry pollFirstEntry(); + + public Float2DoubleMap.Entry pollLastEntry(); @Override public Float2DoubleOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet float2DoubleEntrySet(); + public default Float2DoubleOrderedMap reversed() { return new AbstractFloat2DoubleMap.ReversedFloat2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatMap.java index 586ef31..7e2eb32 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatMap.java @@ -93,7 +93,7 @@ public interface Float2FloatMap extends Map, FloatUnaryOperator * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatOrderedMap.java index 9c77544..d0bc3b9 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2FloatMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2FloatOrderedMap extends Float2FloatMap */ public float putAndMoveToLast(float key, float 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 float putFirst(float key, float 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 float putLast(float key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2FloatOrderedMap extends Float2FloatMap */ public float lastFloatValue(); + + public Float2FloatMap.Entry firstEntry(); + + public Float2FloatMap.Entry lastEntry(); + + public Float2FloatMap.Entry pollFirstEntry(); + + public Float2FloatMap.Entry pollLastEntry(); @Override public Float2FloatOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet float2FloatEntrySet(); + public default Float2FloatOrderedMap reversed() { return new AbstractFloat2FloatMap.ReversedFloat2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntMap.java index 7239358..43e1932 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntMap.java @@ -94,7 +94,7 @@ public interface Float2IntMap extends Map, Float2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntOrderedMap.java index e3c06ea..ac508fa 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2IntMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2IntOrderedMap extends Float2IntMap */ public int putAndMoveToLast(float key, int 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 int putFirst(float key, int 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 int putLast(float key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2IntOrderedMap extends Float2IntMap */ public int lastIntValue(); + + public Float2IntMap.Entry firstEntry(); + + public Float2IntMap.Entry lastEntry(); + + public Float2IntMap.Entry pollFirstEntry(); + + public Float2IntMap.Entry pollLastEntry(); @Override public Float2IntOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet float2IntEntrySet(); + public default Float2IntOrderedMap reversed() { return new AbstractFloat2IntMap.ReversedFloat2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongMap.java index 48042c9..9c62d42 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongMap.java @@ -94,7 +94,7 @@ public interface Float2LongMap extends Map, Float2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongOrderedMap.java index 581e476..4324e2a 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2LongMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2LongOrderedMap extends Float2LongMap */ public long putAndMoveToLast(float key, long 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 long putFirst(float key, long 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 long putLast(float key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2LongOrderedMap extends Float2LongMap */ public long lastLongValue(); + + public Float2LongMap.Entry firstEntry(); + + public Float2LongMap.Entry lastEntry(); + + public Float2LongMap.Entry pollFirstEntry(); + + public Float2LongMap.Entry pollLastEntry(); @Override public Float2LongOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet float2LongEntrySet(); + public default Float2LongOrderedMap reversed() { return new AbstractFloat2LongMap.ReversedFloat2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectMap.java index 3206346..fb404c3 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectMap.java @@ -95,7 +95,7 @@ public interface Float2ObjectMap extends Map, FloatFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectOrderedMap.java index 3073473..c4b420d 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2ObjectMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Float2ObjectOrderedMap extends Float2ObjectMap */ public V putAndMoveToLast(float key, V 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 V putFirst(float key, V 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 V putLast(float key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Float2ObjectOrderedMap extends Float2ObjectMap */ public V lastValue(); + + public Float2ObjectMap.Entry firstEntry(); + + public Float2ObjectMap.Entry lastEntry(); + + public Float2ObjectMap.Entry pollFirstEntry(); + + public Float2ObjectMap.Entry pollLastEntry(); @Override public Float2ObjectOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> float2ObjectEntrySet(); + public default Float2ObjectOrderedMap reversed() { return new AbstractFloat2ObjectMap.ReversedFloat2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortMap.java index c6f8a04..e3c9c3b 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortMap.java @@ -94,7 +94,7 @@ public interface Float2ShortMap extends Map, Float2ShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().floatValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortOrderedMap.java b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortOrderedMap.java index bfe2fb6..1913f33 100644 --- a/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/floats/maps/interfaces/Float2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.floats.maps.interfaces; import speiger.src.collections.floats.utils.maps.Float2ShortMaps; +import speiger.src.collections.floats.maps.abstracts.AbstractFloat2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Float2ShortOrderedMap extends Float2ShortMap */ public short putAndMoveToLast(float key, short 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 short putFirst(float key, short 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 short putLast(float key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Float2ShortOrderedMap extends Float2ShortMap */ public short lastShortValue(); + + public Float2ShortMap.Entry firstEntry(); + + public Float2ShortMap.Entry lastEntry(); + + public Float2ShortMap.Entry pollFirstEntry(); + + public Float2ShortMap.Entry pollLastEntry(); @Override public Float2ShortOrderedMap copy(); @Override public FloatOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet float2ShortEntrySet(); + public default Float2ShortOrderedMap reversed() { return new AbstractFloat2ShortMap.ReversedFloat2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/sets/AbstractFloatSet.java b/src/main/java/speiger/src/collections/floats/sets/AbstractFloatSet.java index 1b3d0c0..0b322de 100644 --- a/src/main/java/speiger/src/collections/floats/sets/AbstractFloatSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/AbstractFloatSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.floats.sets; import java.util.Set; import speiger.src.collections.floats.collections.AbstractFloatCollection; +import speiger.src.collections.floats.collections.FloatBidirectionalIterator; import speiger.src.collections.floats.collections.FloatIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractFloatSet extends AbstractFloatCollection implement return false; } } + + public static class ReversedFloatOrderedSet extends AbstractFloatSet implements FloatOrderedSet { + protected FloatOrderedSet set; + + public ReversedFloatOrderedSet(FloatOrderedSet set) { + this.set = set; + } + + @Override + public ReversedFloatOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public FloatBidirectionalIterator iterator(float fromElement) { + return set.iterator(fromElement); + } + + @Override + public FloatBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public FloatBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(float o) { + return set.remove(o); + } + + @Override + public boolean add(float o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(float o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(float o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(float o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(float o) { + return set.moveToFirst(o); + } + + @Override + public float getFirstFloat() { + return set.getLastFloat(); + } + + @Override + public float removeFirstFloat() { + return set.removeLastFloat(); + } + + @Override + public float getLastFloat() { + return set.getFirstFloat(); + } + + @Override + public float removeLastFloat() { + return set.removeFirstFloat(); + } + + @Override + public FloatOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatArraySet.java b/src/main/java/speiger/src/collections/floats/sets/FloatArraySet.java index fc00a86..e89812b 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatArraySet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatArraySet.java @@ -186,13 +186,13 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet } @Override - public float firstFloat() { + public float getFirstFloat() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public float lastFloat() { + public float getLastFloat() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -283,7 +283,7 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { if(size == 0) throw new NoSuchElementException(); float result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -291,7 +291,7 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet } @Override - public float pollLastFloat() { + public float removeLastFloat() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -414,13 +414,18 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet @Override public FloatBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public FloatBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public FloatBidirectionalIterator iterator(float fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -471,45 +476,57 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet } private class SetIterator implements FloatListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public float nextFloat() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public float previousFloat() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -529,15 +546,23 @@ public class FloatArraySet extends AbstractFloatSet implements FloatOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenCustomHashSet.java index e179af1..6ee7f04 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public boolean moveToFirst(float o) { - if(isEmpty() || strategy.equals(firstFloat(), o)) return false; + if(isEmpty() || strategy.equals(getFirstFloat(), o)) return false; if(strategy.equals(o, 0F)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public boolean moveToLast(float o) { - if(isEmpty() || strategy.equals(lastFloat(), o)) return false; + if(isEmpty() || strategy.equals(getLastFloat(), o)) return false; if(strategy.equals(o, 0F)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme } @Override - public float firstFloat() { + public float getFirstFloat() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme } @Override - public float lastFloat() { + public float getLastFloat() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public float pollLastFloat() { + public float removeLastFloat() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public FloatListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme } private class SetIterator implements FloatListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(float from) { + this.forward = true; if(strategy.equals(from, 0F)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public float previousFloat() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class FloatLinkedOpenCustomHashSet extends FloatOpenCustomHashSet impleme @Override public float nextFloat() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenHashSet.java index 6a986e0..9626db9 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public boolean moveToFirst(float o) { - if(isEmpty() || Float.floatToIntBits(firstFloat()) == Float.floatToIntBits(o)) return false; + if(isEmpty() || Float.floatToIntBits(getFirstFloat()) == Float.floatToIntBits(o)) return false; if(Float.floatToIntBits(o) == 0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public boolean moveToLast(float o) { - if(isEmpty() || Float.floatToIntBits(lastFloat()) == Float.floatToIntBits(o)) return false; + if(isEmpty() || Float.floatToIntBits(getLastFloat()) == Float.floatToIntBits(o)) return false; if(Float.floatToIntBits(o) == 0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd } @Override - public float firstFloat() { + public float getFirstFloat() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public float pollFirstFloat() { + public float removeFirstFloat() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd } @Override - public float lastFloat() { + public float getLastFloat() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public float pollLastFloat() { + public float removeLastFloat() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public FloatListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd } private class SetIterator implements FloatListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(float from) { + this.forward = true; if(Float.floatToIntBits(from) == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public float previousFloat() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class FloatLinkedOpenHashSet extends FloatOpenHashSet implements FloatOrd @Override public float nextFloat() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatNavigableSet.java b/src/main/java/speiger/src/collections/floats/sets/FloatNavigableSet.java index ac7fc46..3f8b487 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatNavigableSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.floats.collections.FloatBidirectionalIterator; import speiger.src.collections.floats.collections.FloatSplititerator; -import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.floats.utils.FloatSplititerators; +import speiger.src.collections.floats.utils.FloatSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatOrderedSet.java b/src/main/java/speiger/src/collections/floats/sets/FloatOrderedSet.java index 9a2bd6c..f02948c 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatOrderedSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.floats.sets; import speiger.src.collections.floats.collections.FloatBidirectionalIterator; import speiger.src.collections.floats.collections.FloatSplititerator; -import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.floats.utils.FloatSplititerators; +import speiger.src.collections.floats.sets.AbstractFloatSet.ReversedFloatOrderedSet; +import speiger.src.collections.floats.utils.FloatSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface FloatOrderedSet extends FloatSet @Override public FloatBidirectionalIterator iterator(); + public FloatBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface FloatOrderedSet extends FloatSet * A method to get the first element in the set * @return first element in the set */ - public float firstFloat(); + public float getFirstFloat(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public float pollFirstFloat(); + public float removeFirstFloat(); /** * A method to get the last element in the set * @return last element in the set */ - public float lastFloat(); + public float getLastFloat(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public float pollLastFloat(); + public float removeLastFloat(); + + public default FloatOrderedSet reversed() { return new ReversedFloatOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/floats/sets/FloatSet.java b/src/main/java/speiger/src/collections/floats/sets/FloatSet.java index c13e57e..2417ed0 100644 --- a/src/main/java/speiger/src/collections/floats/sets/FloatSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/FloatSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.floats.collections.FloatCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.collections.FloatSplititerator; -import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.floats.utils.FloatSplititerators; +import speiger.src.collections.floats.utils.FloatSets; /** diff --git a/src/main/java/speiger/src/collections/floats/sets/ImmutableFloatOpenHashSet.java b/src/main/java/speiger/src/collections/floats/sets/ImmutableFloatOpenHashSet.java index 762b571..54b3805 100644 --- a/src/main/java/speiger/src/collections/floats/sets/ImmutableFloatOpenHashSet.java +++ b/src/main/java/speiger/src/collections/floats/sets/ImmutableFloatOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float } @Override - public float firstFloat() { + public float getFirstFloat() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { + public float getLastFloat() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float @Override public FloatListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public FloatListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float } private class SetIterator implements FloatListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(float from) { + this.forward = true; if(Float.floatToIntBits(from) == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float @Override public float previousFloat() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableFloatOpenHashSet extends AbstractFloatSet implements Float @Override public float nextFloat() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/floats/utils/FloatCollections.java b/src/main/java/speiger/src/collections/floats/utils/FloatCollections.java index 7fa9b7b..f471905 100644 --- a/src/main/java/speiger/src/collections/floats/utils/FloatCollections.java +++ b/src/main/java/speiger/src/collections/floats/utils/FloatCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.floats.collections.AbstractFloatCollection; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -51,6 +52,34 @@ public class FloatCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static FloatOrderedCollection unmodifiable(FloatOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static FloatOrderedCollection synchronize(FloatOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static FloatOrderedCollection synchronize(FloatOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -584,6 +613,37 @@ public class FloatCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements FloatOrderedCollection { + FloatOrderedCollection c; + + SynchronizedOrderedCollection(FloatOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(FloatOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public FloatOrderedCollection reversed() { return FloatCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(float e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(float e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public float getFirstFloat() { synchronized(mutex) { return this.c.getFirstFloat(); } } + @Override + public float removeFirstFloat() { synchronized(mutex) { return this.c.removeFirstFloat(); } } + @Override + public float getLastFloat() { synchronized(mutex) { return this.c.getLastFloat(); } } + @Override + public float removeLastFloat() { synchronized(mutex) { return this.c.removeLastFloat(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -705,6 +765,33 @@ public class FloatCollections public int count(FloatPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements FloatOrderedCollection { + FloatOrderedCollection c; + + UnmodifiableOrderedCollection(FloatOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public FloatOrderedCollection reversed() { return FloatCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return c.getFirstFloat(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return c.getLastFloat(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/floats/utils/FloatIterators.java b/src/main/java/speiger/src/collections/floats/utils/FloatIterators.java index d8ac4b4..62db8a5 100644 --- a/src/main/java/speiger/src/collections/floats/utils/FloatIterators.java +++ b/src/main/java/speiger/src/collections/floats/utils/FloatIterators.java @@ -34,7 +34,7 @@ public class FloatIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static FloatListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class FloatIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(float... a) { + public static FloatIterator wrap(float... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class FloatIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(float[] a, int start, int end) { + public static FloatIterator wrap(float[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/floats/utils/FloatLists.java b/src/main/java/speiger/src/collections/floats/utils/FloatLists.java index fad29f8..817f8b0 100644 --- a/src/main/java/speiger/src/collections/floats/utils/FloatLists.java +++ b/src/main/java/speiger/src/collections/floats/utils/FloatLists.java @@ -30,7 +30,7 @@ public class FloatLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static FloatList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/floats/utils/FloatSets.java b/src/main/java/speiger/src/collections/floats/utils/FloatSets.java index de6677b..117b8e2 100644 --- a/src/main/java/speiger/src/collections/floats/utils/FloatSets.java +++ b/src/main/java/speiger/src/collections/floats/utils/FloatSets.java @@ -312,17 +312,19 @@ public class FloatSets @Override public FloatBidirectionalIterator iterator() { return FloatIterators.unmodifiable(s.iterator()); } @Override + public FloatBidirectionalIterator reverseIterator() { return FloatIterators.unmodifiable(s.reverseIterator()); } + @Override public FloatBidirectionalIterator iterator(float fromElement) { return FloatIterators.unmodifiable(s.iterator(fromElement)); } @Override public FloatOrderedSet copy() { return s.copy(); } @Override - public float firstFloat() { return s.firstFloat(); } + public float getFirstFloat() { return s.getFirstFloat(); } @Override - public float pollFirstFloat() { throw new UnsupportedOperationException(); } + public float removeFirstFloat() { throw new UnsupportedOperationException(); } @Override - public float lastFloat() { return s.lastFloat(); } + public float getLastFloat() { return s.getLastFloat(); } @Override - public float pollLastFloat() { throw new UnsupportedOperationException(); } + public float removeLastFloat() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements FloatSortedSet @@ -583,17 +585,19 @@ public class FloatSets @Override public FloatBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public FloatBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public FloatBidirectionalIterator iterator(float fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public FloatOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public float firstFloat() { synchronized(mutex) { return s.firstFloat(); } } + public float getFirstFloat() { synchronized(mutex) { return s.getFirstFloat(); } } @Override - public float pollFirstFloat() { synchronized(mutex) { return s.pollFirstFloat(); } } + public float removeFirstFloat() { synchronized(mutex) { return s.removeFirstFloat(); } } @Override - public float lastFloat() { synchronized(mutex) { return s.lastFloat(); } } + public float getLastFloat() { synchronized(mutex) { return s.getLastFloat(); } } @Override - public float pollLastFloat() { synchronized(mutex) { return s.pollLastFloat(); } } + public float removeLastFloat() { synchronized(mutex) { return s.removeLastFloat(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2BooleanMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2BooleanMaps.java index e2fc89c..9f82fb6 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Float2BooleanMaps @Override public boolean putAndMoveToLast(float key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(float key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(float key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Float2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Float2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2BooleanOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet float2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Float2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2BooleanMap.Entry first() { return set.first(); } + public Float2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2BooleanMap.Entry last() { return set.last(); } + public Float2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Float2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Float2BooleanMaps @Override public boolean putAndMoveToLast(float key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(float key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(float key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Float2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Float2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet float2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ByteMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ByteMaps.java index 4bef7b8..4b15398 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ByteMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Float2ByteMaps @Override public byte putAndMoveToLast(float key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(float key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(float key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Float2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2ByteOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet float2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Float2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2ByteMap.Entry first() { return set.first(); } + public Float2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ByteMap.Entry last() { return set.last(); } + public Float2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Float2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2ByteMaps @Override public byte putAndMoveToLast(float key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(float key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(float key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Float2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet float2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2CharMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2CharMaps.java index 29c60ed..fa534e7 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2CharMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Float2CharMaps @Override public char putAndMoveToLast(float key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(float key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(float key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Float2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2CharOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet float2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2CharEntrySet()); @@ -617,15 +634,17 @@ public class Float2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2CharMap.Entry first() { return set.first(); } + public Float2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2CharMap.Entry last() { return set.last(); } + public Float2CharMap.Entry getLast() { return set.getLast(); } @Override - public Float2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2CharMaps @Override public char putAndMoveToLast(float key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(float key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(float key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Float2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet float2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2DoubleMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2DoubleMaps.java index ccfec8e..3114981 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Float2DoubleMaps @Override public double putAndMoveToLast(float key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(float key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(float key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Float2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2DoubleOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet float2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Float2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2DoubleMap.Entry first() { return set.first(); } + public Float2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2DoubleMap.Entry last() { return set.last(); } + public Float2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Float2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2DoubleMaps @Override public double putAndMoveToLast(float key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(float key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(float key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Float2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet float2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2FloatMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2FloatMaps.java index 57de78c..61fdfaa 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2FloatMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -438,6 +439,10 @@ public class Float2FloatMaps @Override public float putAndMoveToLast(float key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(float key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(float key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Float2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Float2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2FloatOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet float2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2FloatEntrySet()); @@ -616,15 +633,17 @@ public class Float2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2FloatMap.Entry first() { return set.first(); } + public Float2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2FloatMap.Entry last() { return set.last(); } + public Float2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Float2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Float2FloatMaps @Override public float putAndMoveToLast(float key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(float key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(float key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Float2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Float2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet float2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2IntMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2IntMaps.java index bb19810..164ed18 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2IntMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Float2IntMaps @Override public int putAndMoveToLast(float key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(float key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(float key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Float2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2IntOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet float2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2IntEntrySet()); @@ -617,15 +634,17 @@ public class Float2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2IntMap.Entry first() { return set.first(); } + public Float2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2IntMap.Entry last() { return set.last(); } + public Float2IntMap.Entry getLast() { return set.getLast(); } @Override - public Float2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2IntMaps @Override public int putAndMoveToLast(float key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(float key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(float key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Float2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet float2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2LongMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2LongMaps.java index 32400c3..f11cb08 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2LongMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Float2LongMaps @Override public long putAndMoveToLast(float key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(float key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(float key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Float2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2LongOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet float2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2LongEntrySet()); @@ -617,15 +634,17 @@ public class Float2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2LongMap.Entry first() { return set.first(); } + public Float2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2LongMap.Entry last() { return set.last(); } + public Float2LongMap.Entry getLast() { return set.getLast(); } @Override - public Float2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2LongMaps @Override public long putAndMoveToLast(float key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(float key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(float key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Float2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet float2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ObjectMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ObjectMaps.java index fc05b5a..4351b2e 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Float2ObjectMaps @Override public V putAndMoveToLast(float key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(float key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(float key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Float2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2ObjectOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> float2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.float2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Float2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Float2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2ObjectMap.Entry first() { return set.first(); } + public Float2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ObjectMap.Entry last() { return set.last(); } + public Float2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Float2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Float2ObjectMaps @Override public V putAndMoveToLast(float key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(float key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(float key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Float2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Float2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> float2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ShortMaps.java b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ShortMaps.java index 18ed15f..cfedf87 100644 --- a/src/main/java/speiger/src/collections/floats/utils/maps/Float2ShortMaps.java +++ b/src/main/java/speiger/src/collections/floats/utils/maps/Float2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.floats.sets.FloatOrderedSet; import speiger.src.collections.floats.sets.FloatSet; import speiger.src.collections.floats.utils.FloatSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Float2ShortMaps @Override public short putAndMoveToLast(float key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(float key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(float key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(float key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(float key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Float2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Float2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Float2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Float2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Float2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Float2ShortOrderedMap copy() { return map.copy(); } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.unmodifiable(map.keySet()); return (FloatOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet float2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.float2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Float2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Float2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Float2ShortMap.Entry first() { return set.first(); } + public Float2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Float2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Float2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Float2ShortMap.Entry last() { return set.last(); } + public Float2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Float2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Float2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Float2ShortMaps @Override public short putAndMoveToLast(float key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(float key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(float key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(float key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(float key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Float2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Float2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Float2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Float2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Float2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Float2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public FloatOrderedSet keySet() { if(keys == null) keys = FloatSets.synchronize(map.keySet(), mutex); return (FloatOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet float2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.float2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/collections/AbstractIntCollection.java b/src/main/java/speiger/src/collections/ints/collections/AbstractIntCollection.java index 6f584cf..e3ba224 100644 --- a/src/main/java/speiger/src/collections/ints/collections/AbstractIntCollection.java +++ b/src/main/java/speiger/src/collections/ints/collections/AbstractIntCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.ints.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.ints.lists.IntListIterator; import speiger.src.collections.ints.functions.IntConsumer; import speiger.src.collections.ints.utils.IntIterators; import speiger.src.collections.ints.utils.IntArrays; @@ -249,4 +251,68 @@ public abstract class AbstractIntCollection extends AbstractCollection if (a.length > size()) a[size()] = 0; return a; } + + public static class ReverseIntOrderedCollection extends AbstractIntCollection implements IntOrderedCollection { + IntOrderedCollection collection; + Supplier reverseIterator; + + public ReverseIntOrderedCollection(IntOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(int o) { return collection.add(o); } + @Override + public IntOrderedCollection reversed() { return collection; } + @Override + public void addFirst(int e) { collection.addLast(e); } + @Override + public void addLast(int e) { collection.addFirst(e); } + @Override + public boolean contains(int e) { return collection.contains(e); } + @Override + public boolean remInt(int e) { return collection.remInt(e); } + @Override + public void clear() { collection.clear(); } + @Override + public int getFirstInt() { return collection.getLastInt(); } + @Override + public int removeFirstInt() { return collection.removeLastInt(); } + @Override + public int getLastInt() { return collection.getFirstInt(); } + @Override + public int removeLastInt() { return collection.removeFirstInt(); } + @Override + public IntIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements IntListIterator { + IntListIterator it; + + public ReverseBiIterator(IntListIterator it) { + this.it = it; + } + + @Override + public int nextInt() { return it.previousInt(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public int previousInt() { return it.nextInt(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(int e) { it.set(e); } + @Override + public void add(int e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/ints/collections/IntBidirectionalIterator.java b/src/main/java/speiger/src/collections/ints/collections/IntBidirectionalIterator.java index c422b0e..ce60b7d 100644 --- a/src/main/java/speiger/src/collections/ints/collections/IntBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/ints/collections/IntBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.ints.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface IntBidirectionalIterator extends IntIterator, ObjectBidirectionalIterator +public interface IntBidirectionalIterator extends IntIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface IntBidirectionalIterator extends IntIterator, ObjectBidirection */ public int previousInt(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Integer previous() { return Integer.valueOf(previousInt()); diff --git a/src/main/java/speiger/src/collections/ints/collections/IntOrderedCollection.java b/src/main/java/speiger/src/collections/ints/collections/IntOrderedCollection.java new file mode 100644 index 0000000..4cd8cc2 --- /dev/null +++ b/src/main/java/speiger/src/collections/ints/collections/IntOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.ints.collections; + +public interface IntOrderedCollection extends IntCollection { + + IntOrderedCollection 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(int 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(int e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public int getFirstInt(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public int removeFirstInt(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public int getLastInt(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public int removeLastInt(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/ints/lists/AbstractIntList.java b/src/main/java/speiger/src/collections/ints/lists/AbstractIntList.java index e3fbfec..a7e1737 100644 --- a/src/main/java/speiger/src/collections/ints/lists/AbstractIntList.java +++ b/src/main/java/speiger/src/collections/ints/lists/AbstractIntList.java @@ -465,7 +465,6 @@ public abstract class AbstractIntList extends AbstractIntCollection implements I public int size() { return size; } - @Override public IntSplititerator spliterator() { return IntSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/ints/lists/IntLinkedList.java b/src/main/java/speiger/src/collections/ints/lists/IntLinkedList.java index 828017c..dfcc5c7 100644 --- a/src/main/java/speiger/src/collections/ints/lists/IntLinkedList.java +++ b/src/main/java/speiger/src/collections/ints/lists/IntLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.ints.functions.IntConsumer; import speiger.src.collections.ints.utils.IntArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.IntStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.ints.collections.IntSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.ints.collections.IntSplititerator; import speiger.src.collections.ints.utils.IntSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class IntLinkedList extends AbstractIntList implements IntPriorityDequeue if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class IntLinkedList extends AbstractIntList implements IntPriorityDequeue * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } - /** + public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/ints/lists/IntList.java b/src/main/java/speiger/src/collections/ints/lists/IntList.java index 679ebfa..cda5a46 100644 --- a/src/main/java/speiger/src/collections/ints/lists/IntList.java +++ b/src/main/java/speiger/src/collections/ints/lists/IntList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntSplititerator; import speiger.src.collections.ints.functions.consumer.IntIntConsumer; import speiger.src.collections.ints.functions.IntComparator; @@ -19,7 +20,7 @@ import speiger.src.collections.ints.utils.IntSplititerators; /** * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features */ -public interface IntList extends IntCollection, List +public interface IntList extends IntOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -82,6 +83,24 @@ public interface IntList extends IntCollection, List */ public boolean addAll(int index, IntList 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(int 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(int e) { + add(e); + } + /** * 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. @@ -412,9 +431,9 @@ public interface IntList extends IntCollection, List @Override @Deprecated public default boolean add(Integer e) { - return IntCollection.super.add(e); + return IntOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -462,7 +481,7 @@ public interface IntList extends IntCollection, List @Override @Deprecated public default boolean contains(Object o) { - return IntCollection.super.contains(o); + return IntOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -472,7 +491,7 @@ public interface IntList extends IntCollection, List @Override @Deprecated public default boolean remove(Object o) { - return IntCollection.super.remove(o); + return IntOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2BooleanMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2BooleanMap.java index 8bacde0..e7c7708 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2BooleanMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.consumer.IntBooleanConsumer; import speiger.src.collections.ints.functions.function.IntBooleanUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2BooleanMap; +import speiger.src.collections.ints.maps.interfaces.Int2BooleanOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractInt2BooleanMap extends AbstractMap int2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2BooleanEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ByteMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ByteMap.java index d872799..57f3e1c 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ByteMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntByteConsumer; import speiger.src.collections.ints.functions.function.Int2ByteFunction; import speiger.src.collections.ints.functions.function.IntByteUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2ByteMap; +import speiger.src.collections.ints.maps.interfaces.Int2ByteOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2ByteMap extends AbstractMap implements Int2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2ByteMap extends AbstractMap imp public void putAll(Integer[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedInt2ByteOrderedMap extends AbstractInt2ByteMap implements Int2ByteOrderedMap { + Int2ByteOrderedMap map; + + public ReversedInt2ByteOrderedMap(Int2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(int key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(int key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(int key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(int key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(int key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(int key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(int key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Int2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(IntByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(int key, IntByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(int key, Int2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(int key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(int key, IntByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(int key, IntByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(int key, Int2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(int key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(int key, IntByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(int key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(int key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(int key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(int key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(int key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(int key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(int key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Int2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2ByteEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2CharMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2CharMap.java index 7924b56..0a35a49 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2CharMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntCharConsumer; import speiger.src.collections.ints.functions.function.Int2CharFunction; import speiger.src.collections.ints.functions.function.IntCharUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2CharMap; +import speiger.src.collections.ints.maps.interfaces.Int2CharOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2CharMap extends AbstractMap implements Int2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2CharMap extends AbstractMap int2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2CharEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2DoubleMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2DoubleMap.java index 3f044b9..dd3c1bb 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2DoubleMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntDoubleConsumer; import speiger.src.collections.ints.functions.function.Int2DoubleFunction; import speiger.src.collections.ints.functions.function.IntDoubleUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2DoubleMap; +import speiger.src.collections.ints.maps.interfaces.Int2DoubleOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2DoubleMap extends AbstractMap implements Int2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2DoubleMap extends AbstractMap public void putAll(Integer[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedInt2DoubleOrderedMap extends AbstractInt2DoubleMap implements Int2DoubleOrderedMap { + Int2DoubleOrderedMap map; + + public ReversedInt2DoubleOrderedMap(Int2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(int key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(int key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(int key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(int key, double value) { return map.subFrom(key, value); } + @Override + public double remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, double value) { return map.remove(key, value); } + @Override + public double removeOrDefault(int key, double defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(int key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(int key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Int2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(IntDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(int key, IntDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(int key, Int2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(int key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(int key, IntDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(int key, IntDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(int key, Int2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(int key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(int key, IntDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(int key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(int key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double get(int key) { return map.get(key); } + @Override + public double putAndMoveToFirst(int key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(int key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(int key, double value) { return map.putLast(key, value); } + @Override + public double putLast(int key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Int2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2DoubleEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2FloatMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2FloatMap.java index cbe8cec..23ce1d4 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2FloatMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntFloatConsumer; import speiger.src.collections.ints.functions.function.Int2FloatFunction; import speiger.src.collections.ints.functions.function.IntFloatUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2FloatMap; +import speiger.src.collections.ints.maps.interfaces.Int2FloatOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2FloatMap extends AbstractMap implements Int2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2FloatMap extends AbstractMap i public void putAll(Integer[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedInt2FloatOrderedMap extends AbstractInt2FloatMap implements Int2FloatOrderedMap { + Int2FloatOrderedMap map; + + public ReversedInt2FloatOrderedMap(Int2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(int key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(int key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(int key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(int key, float value) { return map.subFrom(key, value); } + @Override + public float remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(int key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(int key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(int key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Int2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(IntFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(int key, IntFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(int key, Int2FloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(int key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(int key, IntFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(int key, IntFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(int key, Int2FloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(int key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(int key, IntFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(int key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(int key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(int key) { return map.get(key); } + @Override + public float putAndMoveToFirst(int key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(int key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(int key, float value) { return map.putLast(key, value); } + @Override + public float putLast(int key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Int2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2FloatEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2IntMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2IntMap.java index f761c2d..82e1bac 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2IntMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntIntConsumer; import speiger.src.collections.ints.functions.function.IntUnaryOperator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2IntMap; +import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2IntMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2IntMap extends AbstractMap implements Int2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractInt2IntMap extends AbstractMap i public void putAll(Integer[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedInt2IntOrderedMap extends AbstractInt2IntMap implements Int2IntOrderedMap { + Int2IntOrderedMap map; + + public ReversedInt2IntOrderedMap(Int2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(int key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(int key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(int key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(int key, int value) { return map.subFrom(key, value); } + @Override + public int remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(int key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(int key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(int key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Int2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(IntIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(int key, IntIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(int key, IntUnaryOperator mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(int key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(int key, IntIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(int key, IntIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(int key, IntUnaryOperator mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(int key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(int key, IntIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(int key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(int key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(int key) { return map.get(key); } + @Override + public int putAndMoveToFirst(int key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(int key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(int key, int value) { return map.putLast(key, value); } + @Override + public int putLast(int key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Int2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2IntEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2LongMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2LongMap.java index da57cbe..ae2097f 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2LongMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntLongConsumer; import speiger.src.collections.ints.functions.function.Int2LongFunction; import speiger.src.collections.ints.functions.function.IntLongUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2LongMap; +import speiger.src.collections.ints.maps.interfaces.Int2LongOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2LongMap extends AbstractMap implements Int2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2LongMap extends AbstractMap imp public void putAll(Integer[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedInt2LongOrderedMap extends AbstractInt2LongMap implements Int2LongOrderedMap { + Int2LongOrderedMap map; + + public ReversedInt2LongOrderedMap(Int2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(int key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(int key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(int key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(int key, long value) { return map.subFrom(key, value); } + @Override + public long remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(int key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(int key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(int key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Int2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(IntLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(int key, IntLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(int key, Int2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(int key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(int key, IntLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(int key, IntLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(int key, Int2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(int key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(int key, IntLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(int key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(int key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(int key) { return map.get(key); } + @Override + public long putAndMoveToFirst(int key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(int key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(int key, long value) { return map.putLast(key, value); } + @Override + public long putLast(int key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Int2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2LongEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ObjectMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ObjectMap.java index 9724824..b050353 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ObjectMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntObjectConsumer; import speiger.src.collections.ints.functions.function.IntFunction; import speiger.src.collections.ints.functions.function.IntObjectUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2ObjectMap; +import speiger.src.collections.ints.maps.interfaces.Int2ObjectOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractInt2ObjectMap extends AbstractMap i public void putAll(Integer[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedInt2ObjectOrderedMap extends AbstractInt2ObjectMap implements Int2ObjectOrderedMap { + Int2ObjectOrderedMap map; + + public ReversedInt2ObjectOrderedMap(Int2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(int key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(int key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(int key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(int key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(int key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Int2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(IntObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(int key, IntObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(int key, IntFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(int key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(int key, IntObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(int key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(int key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(int key) { return map.get(key); } + @Override + public V putAndMoveToFirst(int key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(int key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(int key, V value) { return map.putLast(key, value); } + @Override + public V putLast(int key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Int2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> int2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2ObjectEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ShortMap.java b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ShortMap.java index c79dc49..14dcf4a 100644 --- a/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ShortMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/abstracts/AbstractInt2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.ints.functions.consumer.IntShortConsumer; import speiger.src.collections.ints.functions.function.Int2ShortFunction; import speiger.src.collections.ints.functions.function.IntShortUnaryOperator; import speiger.src.collections.ints.maps.interfaces.Int2ShortMap; +import speiger.src.collections.ints.maps.interfaces.Int2ShortOrderedMap; +import speiger.src.collections.ints.sets.IntOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.maps.Int2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractInt2ShortMap extends AbstractMap implements Int2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractInt2ShortMap extends AbstractMap i public void putAll(Integer[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedInt2ShortOrderedMap extends AbstractInt2ShortMap implements Int2ShortOrderedMap { + Int2ShortOrderedMap map; + + public ReversedInt2ShortOrderedMap(Int2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractInt2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Int2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(int key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(int key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(int key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(int key, short value) { return map.subFrom(key, value); } + @Override + public short remove(int key) { return map.remove(key); } + @Override + public boolean remove(int key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(int key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(int key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(int key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(int key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Int2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(IntShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(int key, IntShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(int key, Int2ShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(int key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(int key, IntShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(int key, IntShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(int key, Int2ShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(int key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(int key, IntShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(int key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(int key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(int key) { return map.get(key); } + @Override + public short putAndMoveToFirst(int key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(int key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(int key, short value) { return map.putLast(key, value); } + @Override + public short putLast(int key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(int key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(int key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(int key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(int key) { return map.getAndMoveToFirst(key); } + @Override + public int firstIntKey() { return map.lastIntKey(); } + @Override + public int pollFirstIntKey() { return map.pollLastIntKey(); } + @Override + public int lastIntKey() { return map.firstIntKey(); } + @Override + public int pollLastIntKey() { return map.pollFirstIntKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Int2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Int2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Int2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Int2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet int2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.int2ShortEntrySet()); } + @Override + public IntOrderedSet keySet() { return new AbstractIntSet.ReversedIntOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Int2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2BooleanLinkedOpenCustomHashMap.java index 0d524d4..d14c224 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2BooleanLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -257,6 +257,54 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas return getDefaultReturnValue(); } + @Override + public boolean putFirst(int key, boolean value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 boolean putLast(int key, boolean value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas return values[lastIndex]; } + @Override + public Int2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } @Override - public Int2BooleanMap.Entry first() { + public Int2BooleanMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstBooleanValue()); } @Override - public Int2BooleanMap.Entry last() { + public Int2BooleanMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastBooleanValue()); } @Override - public Int2BooleanMap.Entry pollFirst() { + public Int2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstBooleanValue()); pollFirstIntKey(); return entry; } @Override - public Int2BooleanMap.Entry pollLast() { + public Int2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastBooleanValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstIntKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Int2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1283,16 +1398,20 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2BooleanLinkedOpenCustomHashMap extends Int2BooleanOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ByteLinkedOpenCustomHashMap.java index cb58ea2..d2c76b6 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ByteLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -257,6 +257,54 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public byte putFirst(int key, byte value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 byte putLast(int key, byte value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i return values[lastIndex]; } + @Override + public Int2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } @Override - public Int2ByteMap.Entry first() { + public Int2ByteMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstByteValue()); } @Override - public Int2ByteMap.Entry last() { + public Int2ByteMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastByteValue()); } @Override - public Int2ByteMap.Entry pollFirst() { + public Int2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstByteValue()); pollFirstIntKey(); return entry; } @Override - public Int2ByteMap.Entry pollLast() { + public Int2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastByteValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstIntKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Int2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1283,16 +1398,20 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2ByteLinkedOpenCustomHashMap extends Int2ByteOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2CharLinkedOpenCustomHashMap.java index 1b3f88d..5731e04 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2CharLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -257,6 +257,54 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public char putFirst(int key, char value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 char putLast(int key, char value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i return values[lastIndex]; } + @Override + public Int2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } @Override - public Int2CharMap.Entry first() { + public Int2CharMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstCharValue()); } @Override - public Int2CharMap.Entry last() { + public Int2CharMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastCharValue()); } @Override - public Int2CharMap.Entry pollFirst() { + public Int2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstCharValue()); pollFirstIntKey(); return entry; } @Override - public Int2CharMap.Entry pollLast() { + public Int2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastCharValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstIntKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Int2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1283,16 +1398,20 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2CharLinkedOpenCustomHashMap extends Int2CharOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2DoubleLinkedOpenCustomHashMap.java index f756a09..4252aca 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2DoubleLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -257,6 +257,54 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM return getDefaultReturnValue(); } + @Override + public double putFirst(int key, double value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 double putLast(int key, double value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM return values[lastIndex]; } + @Override + public Int2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } @Override - public Int2DoubleMap.Entry first() { + public Int2DoubleMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstDoubleValue()); } @Override - public Int2DoubleMap.Entry last() { + public Int2DoubleMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastDoubleValue()); } @Override - public Int2DoubleMap.Entry pollFirst() { + public Int2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstDoubleValue()); pollFirstIntKey(); return entry; } @Override - public Int2DoubleMap.Entry pollLast() { + public Int2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastDoubleValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstIntKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Int2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1283,16 +1398,20 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2DoubleLinkedOpenCustomHashMap extends Int2DoubleOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2FloatLinkedOpenCustomHashMap.java index d61d94b..f6add50 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2FloatLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -257,6 +257,54 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public float putFirst(int key, float value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 float putLast(int key, float value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap return values[lastIndex]; } + @Override + public Int2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } @Override - public Int2FloatMap.Entry first() { + public Int2FloatMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstFloatValue()); } @Override - public Int2FloatMap.Entry last() { + public Int2FloatMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastFloatValue()); } @Override - public Int2FloatMap.Entry pollFirst() { + public Int2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstFloatValue()); pollFirstIntKey(); return entry; } @Override - public Int2FloatMap.Entry pollLast() { + public Int2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastFloatValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstIntKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Int2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1283,16 +1398,20 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2FloatLinkedOpenCustomHashMap extends Int2FloatOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2IntLinkedOpenCustomHashMap.java index 9224f1e..78d45a7 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2IntLinkedOpenCustomHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -250,6 +250,54 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp return getDefaultReturnValue(); } + @Override + public int putFirst(int key, int value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 int putLast(int key, int value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -385,6 +433,52 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp return values[lastIndex]; } + @Override + public Int2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -398,9 +492,9 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -585,24 +679,24 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } @Override - public Int2IntMap.Entry first() { + public Int2IntMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstIntValue()); } @Override - public Int2IntMap.Entry last() { + public Int2IntMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastIntValue()); } @Override - public Int2IntMap.Entry pollFirst() { + public Int2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstIntValue()); pollFirstIntKey(); return entry; } @Override - public Int2IntMap.Entry pollLast() { + public Int2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastIntValue()); pollLastIntKey(); return entry; @@ -610,7 +704,12 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -620,7 +719,7 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -856,7 +955,12 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -878,22 +982,22 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1022,30 +1126,41 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstIntKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Int2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastIntKey(); + return result; } @Override @@ -1176,7 +1291,7 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1203,7 +1318,7 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1233,7 +1348,7 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1255,7 +1370,7 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1276,16 +1391,20 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1313,11 +1432,11 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1377,20 +1496,30 @@ public class Int2IntLinkedOpenCustomHashMap extends Int2IntOpenCustomHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2LongLinkedOpenCustomHashMap.java index 5419c03..a794c69 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2LongLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -257,6 +257,54 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public long putFirst(int key, long value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 long putLast(int key, long value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i return values[lastIndex]; } + @Override + public Int2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } @Override - public Int2LongMap.Entry first() { + public Int2LongMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstLongValue()); } @Override - public Int2LongMap.Entry last() { + public Int2LongMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastLongValue()); } @Override - public Int2LongMap.Entry pollFirst() { + public Int2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstLongValue()); pollFirstIntKey(); return entry; } @Override - public Int2LongMap.Entry pollLast() { + public Int2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastLongValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstIntKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Int2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1283,16 +1398,20 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2LongLinkedOpenCustomHashMap extends Int2LongOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ObjectLinkedOpenCustomHashMap.java index 451dd7e..4ef18df 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ObjectLinkedOpenCustomHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -252,6 +252,54 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa return getDefaultReturnValue(); } + @Override + public V putFirst(int key, V value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 V putLast(int key, V value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -387,6 +435,52 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa return values[lastIndex]; } + @Override + public Int2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> int2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -400,9 +494,9 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -587,24 +681,24 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } @Override - public Int2ObjectMap.Entry first() { + public Int2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstIntKey(), firstValue()); } @Override - public Int2ObjectMap.Entry last() { + public Int2ObjectMap.Entry getLast() { return new BasicEntry<>(lastIntKey(), lastValue()); } @Override - public Int2ObjectMap.Entry pollFirst() { + public Int2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstIntKey(), firstValue()); pollFirstIntKey(); return entry; } @Override - public Int2ObjectMap.Entry pollLast() { + public Int2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastIntKey(), lastValue()); pollLastIntKey(); return entry; @@ -612,7 +706,12 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -622,7 +721,7 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,31 +1128,42 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Int2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Int2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Int2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstIntKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastIntKey(); + return result; } @Override @@ -1179,7 +1294,7 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1279,16 +1394,20 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1316,11 +1435,11 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1499,30 @@ public class Int2ObjectLinkedOpenCustomHashMap extends Int2ObjectOpenCustomHa public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ShortLinkedOpenCustomHashMap.java index ba2df4a..e29aa1c 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/customHash/Int2ShortLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.utils.IntStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -257,6 +257,54 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public short putFirst(int key, short value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + 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 short putLast(int key, short value) { + if(strategy.equals(key, 0)) { + 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], 0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || strategy.equals(firstIntKey(), key)) return false; @@ -392,6 +440,52 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap return values[lastIndex]; } + @Override + public Int2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getIntKey(), 0)) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -405,9 +499,9 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -592,24 +686,24 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } @Override - public Int2ShortMap.Entry first() { + public Int2ShortMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstShortValue()); } @Override - public Int2ShortMap.Entry last() { + public Int2ShortMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastShortValue()); } @Override - public Int2ShortMap.Entry pollFirst() { + public Int2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstShortValue()); pollFirstIntKey(); return entry; } @Override - public Int2ShortMap.Entry pollLast() { + public Int2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastShortValue()); pollLastIntKey(); return entry; @@ -617,7 +711,12 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -627,7 +726,7 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +962,12 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -885,22 +989,22 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1029,30 +1133,41 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Int2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Int2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstIntKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Int2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Int2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastIntKey(); + return result; } @Override @@ -1183,7 +1298,7 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1210,7 +1325,7 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1240,7 +1355,7 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1262,7 +1377,7 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1283,16 +1398,20 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1320,11 +1439,11 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1384,20 +1503,30 @@ public class Int2ShortLinkedOpenCustomHashMap extends Int2ShortOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2BooleanLinkedOpenHashMap.java index 64d5b27..9826fa3 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2BooleanLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2BooleanOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -234,6 +234,54 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public boolean putFirst(int key, boolean value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 boolean putLast(int key, boolean value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme return values[lastIndex]; } + @Override + public Int2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } @Override - public Int2BooleanMap.Entry first() { + public Int2BooleanMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstBooleanValue()); } @Override - public Int2BooleanMap.Entry last() { + public Int2BooleanMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastBooleanValue()); } @Override - public Int2BooleanMap.Entry pollFirst() { + public Int2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstBooleanValue()); pollFirstIntKey(); return entry; } @Override - public Int2BooleanMap.Entry pollLast() { + public Int2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastBooleanValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Int2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstIntKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1278,13 +1393,16 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2BooleanLinkedOpenHashMap extends Int2BooleanOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ByteLinkedOpenHashMap.java index 26ba597..8d88b4f 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ByteLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ByteOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -234,6 +234,54 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In return getDefaultReturnValue(); } + @Override + public byte putFirst(int key, byte value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 byte putLast(int key, byte value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In return values[lastIndex]; } + @Override + public Int2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } @Override - public Int2ByteMap.Entry first() { + public Int2ByteMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstByteValue()); } @Override - public Int2ByteMap.Entry last() { + public Int2ByteMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastByteValue()); } @Override - public Int2ByteMap.Entry pollFirst() { + public Int2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstByteValue()); pollFirstIntKey(); return entry; } @Override - public Int2ByteMap.Entry pollLast() { + public Int2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastByteValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Int2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstIntKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1278,13 +1393,16 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2ByteLinkedOpenHashMap extends Int2ByteOpenHashMap implements In public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2CharLinkedOpenHashMap.java index 4928129..2ccda04 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2CharLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2CharOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -234,6 +234,54 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In return getDefaultReturnValue(); } + @Override + public char putFirst(int key, char value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 char putLast(int key, char value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In return values[lastIndex]; } + @Override + public Int2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } @Override - public Int2CharMap.Entry first() { + public Int2CharMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstCharValue()); } @Override - public Int2CharMap.Entry last() { + public Int2CharMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastCharValue()); } @Override - public Int2CharMap.Entry pollFirst() { + public Int2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstCharValue()); pollFirstIntKey(); return entry; } @Override - public Int2CharMap.Entry pollLast() { + public Int2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastCharValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2CharLinkedOpenHashMap.this.clear(); + public void clear() { Int2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstIntKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1278,13 +1393,16 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2CharLinkedOpenHashMap extends Int2CharOpenHashMap implements In public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2DoubleLinkedOpenHashMap.java index b02f4e8..4cbe02b 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2DoubleLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2DoubleOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -234,6 +234,54 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement return getDefaultReturnValue(); } + @Override + public double putFirst(int key, double value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 double putLast(int key, double value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement return values[lastIndex]; } + @Override + public Int2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } @Override - public Int2DoubleMap.Entry first() { + public Int2DoubleMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstDoubleValue()); } @Override - public Int2DoubleMap.Entry last() { + public Int2DoubleMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastDoubleValue()); } @Override - public Int2DoubleMap.Entry pollFirst() { + public Int2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstDoubleValue()); pollFirstIntKey(); return entry; } @Override - public Int2DoubleMap.Entry pollLast() { + public Int2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastDoubleValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Int2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstIntKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1278,13 +1393,16 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2DoubleLinkedOpenHashMap extends Int2DoubleOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2FloatLinkedOpenHashMap.java index 3257cc4..d08b00a 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2FloatLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2FloatOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -234,6 +234,54 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements return getDefaultReturnValue(); } + @Override + public float putFirst(int key, float value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 float putLast(int key, float value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements return values[lastIndex]; } + @Override + public Int2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } @Override - public Int2FloatMap.Entry first() { + public Int2FloatMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstFloatValue()); } @Override - public Int2FloatMap.Entry last() { + public Int2FloatMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastFloatValue()); } @Override - public Int2FloatMap.Entry pollFirst() { + public Int2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstFloatValue()); pollFirstIntKey(); return entry; } @Override - public Int2FloatMap.Entry pollLast() { + public Int2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastFloatValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Int2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstIntKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1278,13 +1393,16 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2FloatLinkedOpenHashMap extends Int2FloatOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2IntLinkedOpenHashMap.java index de29939..31c7cf9 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2IntLinkedOpenHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -227,6 +227,54 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 return getDefaultReturnValue(); } + @Override + public int putFirst(int key, int value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 int putLast(int key, int value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -383,6 +431,52 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 return values[lastIndex]; } + @Override + public Int2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -396,9 +490,9 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -583,24 +677,24 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } @Override - public Int2IntMap.Entry first() { + public Int2IntMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstIntValue()); } @Override - public Int2IntMap.Entry last() { + public Int2IntMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastIntValue()); } @Override - public Int2IntMap.Entry pollFirst() { + public Int2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstIntValue()); pollFirstIntKey(); return entry; } @Override - public Int2IntMap.Entry pollLast() { + public Int2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastIntValue()); pollLastIntKey(); return entry; @@ -608,7 +702,12 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -618,7 +717,7 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1017,32 +1121,43 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2IntLinkedOpenHashMap.this.clear(); + public void clear() { Int2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstIntKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1199,7 +1314,7 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1229,7 +1344,7 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1251,7 +1366,7 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1271,13 +1386,16 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1308,11 +1426,11 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Int2IntLinkedOpenHashMap extends Int2IntOpenHashMap implements Int2 public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2LongLinkedOpenHashMap.java index 6bbbf48..63559f2 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2LongLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2LongOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -234,6 +234,54 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In return getDefaultReturnValue(); } + @Override + public long putFirst(int key, long value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 long putLast(int key, long value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In return values[lastIndex]; } + @Override + public Int2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } @Override - public Int2LongMap.Entry first() { + public Int2LongMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstLongValue()); } @Override - public Int2LongMap.Entry last() { + public Int2LongMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastLongValue()); } @Override - public Int2LongMap.Entry pollFirst() { + public Int2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstLongValue()); pollFirstIntKey(); return entry; } @Override - public Int2LongMap.Entry pollLast() { + public Int2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastLongValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2LongLinkedOpenHashMap.this.clear(); + public void clear() { Int2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstIntKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1278,13 +1393,16 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2LongLinkedOpenHashMap extends Int2LongOpenHashMap implements In public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ObjectLinkedOpenHashMap.java index d7d5c88..98a0a89 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ObjectLinkedOpenHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ObjectOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -229,6 +229,54 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp return getDefaultReturnValue(); } + @Override + public V putFirst(int key, V value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 V putLast(int key, V value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -374,6 +422,52 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp return values[lastIndex]; } + @Override + public Int2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> int2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -387,9 +481,9 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -574,24 +668,24 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } @Override - public Int2ObjectMap.Entry first() { + public Int2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstIntKey(), firstValue()); } @Override - public Int2ObjectMap.Entry last() { + public Int2ObjectMap.Entry getLast() { return new BasicEntry<>(lastIntKey(), lastValue()); } @Override - public Int2ObjectMap.Entry pollFirst() { + public Int2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstIntKey(), firstValue()); pollFirstIntKey(); return entry; } @Override - public Int2ObjectMap.Entry pollLast() { + public Int2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastIntKey(), lastValue()); pollLastIntKey(); return entry; @@ -599,7 +693,12 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -609,7 +708,7 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -842,7 +941,12 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -864,22 +968,22 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1008,33 +1112,44 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Int2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstIntKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1164,7 +1279,7 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1191,7 +1306,7 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1221,7 +1336,7 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1243,7 +1358,7 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1263,13 +1378,16 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1300,11 +1418,11 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1364,20 +1482,30 @@ public class Int2ObjectLinkedOpenHashMap extends Int2ObjectOpenHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ShortLinkedOpenHashMap.java index 3e75cff..99201b1 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/hash/Int2ShortLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ShortOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -234,6 +234,54 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements return getDefaultReturnValue(); } + @Override + public short putFirst(int key, short value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(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 short putLast(int key, short value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Integer.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(int key) { if(isEmpty() || firstIntKey() == key) return false; @@ -390,6 +438,52 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements return values[lastIndex]; } + @Override + public Int2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Int2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getIntKey() == 0) { + containsNull = false; + keys[nullIndex] = 0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet int2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -403,9 +497,9 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -590,24 +684,24 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } @Override - public Int2ShortMap.Entry first() { + public Int2ShortMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstShortValue()); } @Override - public Int2ShortMap.Entry last() { + public Int2ShortMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastShortValue()); } @Override - public Int2ShortMap.Entry pollFirst() { + public Int2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstShortValue()); pollFirstIntKey(); return entry; } @Override - public Int2ShortMap.Entry pollLast() { + public Int2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastShortValue()); pollLastIntKey(); return entry; @@ -615,7 +709,12 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -625,7 +724,7 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -858,7 +957,12 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -880,22 +984,22 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { + public int removeLastInt() { return pollLastIntKey(); } @@ -1024,32 +1128,43 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Int2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Int2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Int2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstIntKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1179,7 +1294,7 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1206,7 +1321,7 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1236,7 +1351,7 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1258,7 +1373,7 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1278,13 +1393,16 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1315,11 +1433,11 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1379,20 +1497,30 @@ public class Int2ShortLinkedOpenHashMap extends Int2ShortOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2BooleanOpenHashMap.java index a737fed..1753c2a 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2BooleanOpenHashMap.java @@ -29,7 +29,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -72,7 +72,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -257,6 +257,10 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl @Override public boolean putAndMoveToLast(int key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(int key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(int key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -359,7 +363,24 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2BooleanEntrySet() { @@ -374,7 +395,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -523,24 +544,29 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl public boolean moveToLast(Int2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2BooleanMap.Entry first() { + public Int2BooleanMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstBooleanValue()); } @Override - public Int2BooleanMap.Entry last() { + public Int2BooleanMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastBooleanValue()); } @Override - public Int2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -550,7 +576,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -765,7 +791,12 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -785,20 +816,20 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -925,30 +956,35 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1077,7 +1113,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1103,7 +1139,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1130,7 +1166,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1152,7 +1188,7 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1173,13 +1209,16 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1210,11 +1249,11 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1231,20 +1270,30 @@ public class ImmutableInt2BooleanOpenHashMap extends AbstractInt2BooleanMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ByteOpenHashMap.java index 03acab0..321b69d 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ByteOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements @Override public byte putAndMoveToLast(int key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(int key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(int key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2ByteEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements public boolean moveToLast(Int2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2ByteMap.Entry first() { + public Int2ByteMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstByteValue()); } @Override - public Int2ByteMap.Entry last() { + public Int2ByteMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastByteValue()); } @Override - public Int2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2ByteOpenHashMap extends AbstractInt2ByteMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2CharOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2CharOpenHashMap.java index c814033..e4c891d 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2CharOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements @Override public char putAndMoveToLast(int key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(int key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(int key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2CharEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements public boolean moveToLast(Int2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2CharMap.Entry first() { + public Int2CharMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstCharValue()); } @Override - public Int2CharMap.Entry last() { + public Int2CharMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastCharValue()); } @Override - public Int2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2CharOpenHashMap extends AbstractInt2CharMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2DoubleOpenHashMap.java index 518af42..cc1fcaa 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2DoubleOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem @Override public double putAndMoveToLast(int key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(int key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(int key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2DoubleEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem public boolean moveToLast(Int2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2DoubleMap.Entry first() { + public Int2DoubleMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstDoubleValue()); } @Override - public Int2DoubleMap.Entry last() { + public Int2DoubleMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastDoubleValue()); } @Override - public Int2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2DoubleOpenHashMap extends AbstractInt2DoubleMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2FloatOpenHashMap.java index 7edc2c2..bb58ea0 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2FloatOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen @Override public float putAndMoveToLast(int key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(int key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(int key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2FloatEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen public boolean moveToLast(Int2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2FloatMap.Entry first() { + public Int2FloatMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstFloatValue()); } @Override - public Int2FloatMap.Entry last() { + public Int2FloatMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastFloatValue()); } @Override - public Int2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2FloatOpenHashMap extends AbstractInt2FloatMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2IntOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2IntOpenHashMap.java index a487b3f..cf37b08 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2IntOpenHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.ints.utils.IntArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -64,7 +64,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I @Override public int putAndMoveToLast(int key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(int key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(int key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -355,7 +359,24 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2IntEntrySet() { @@ -370,7 +391,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -519,24 +540,29 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I public boolean moveToLast(Int2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2IntMap.Entry first() { + public Int2IntMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstIntValue()); } @Override - public Int2IntMap.Entry last() { + public Int2IntMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastIntValue()); } @Override - public Int2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -546,7 +572,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -761,7 +787,12 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -781,20 +812,20 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -921,30 +952,35 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1073,7 +1109,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1099,7 +1135,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1126,7 +1162,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1148,7 +1184,7 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1169,13 +1205,16 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1206,11 +1245,11 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1227,20 +1266,30 @@ public class ImmutableInt2IntOpenHashMap extends AbstractInt2IntMap implements I public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2LongOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2LongOpenHashMap.java index 17a53a1..ddd7b15 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2LongOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements @Override public long putAndMoveToLast(int key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(int key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(int key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2LongEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements public boolean moveToLast(Int2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2LongMap.Entry first() { + public Int2LongMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstLongValue()); } @Override - public Int2LongMap.Entry last() { + public Int2LongMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastLongValue()); } @Override - public Int2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2LongOpenHashMap extends AbstractInt2LongMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ObjectOpenHashMap.java index 5556e87..b858713 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ObjectOpenHashMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -67,7 +67,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient ObjectCollection valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -252,6 +252,10 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap @Override public V putAndMoveToLast(int key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(int key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(int key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -343,7 +347,24 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap public V lastValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> int2ObjectEntrySet() { @@ -358,7 +379,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -499,24 +520,29 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap public boolean moveToLast(Int2ObjectMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2ObjectMap.Entry first() { + public Int2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstIntKey(), firstValue()); } @Override - public Int2ObjectMap.Entry last() { + public Int2ObjectMap.Entry getLast() { return new BasicEntry<>(lastIntKey(), lastValue()); } @Override - public Int2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -741,7 +767,12 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -761,20 +792,20 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -901,31 +932,36 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1054,7 +1090,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1150,13 +1186,16 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1187,11 +1226,11 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1208,20 +1247,30 @@ public class ImmutableInt2ObjectOpenHashMap extends AbstractInt2ObjectMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ShortOpenHashMap.java index 60975d5..8067a31 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/immutable/ImmutableInt2ShortOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen /** KeySet cache */ protected transient IntOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -262,6 +262,10 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen @Override public short putAndMoveToLast(int key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(int key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(int key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -364,7 +368,24 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Int2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Int2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Int2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet int2ShortEntrySet() { @@ -379,7 +400,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -528,24 +549,29 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen public boolean moveToLast(Int2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Int2ShortMap.Entry first() { + public Int2ShortMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstShortValue()); } @Override - public Int2ShortMap.Entry last() { + public Int2ShortMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastShortValue()); } @Override - public Int2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -555,7 +581,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -770,7 +796,12 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen @Override public IntListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -790,20 +821,20 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public int firstInt() { + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { @@ -930,30 +961,35 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableInt2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableInt2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1082,7 +1118,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(int from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(int from) { super(from); } @@ -1135,7 +1171,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(int from) { super(from); } @@ -1157,7 +1193,7 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1178,13 +1214,16 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(int from) { @@ -1215,11 +1254,11 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1236,20 +1275,30 @@ public class ImmutableInt2ShortOpenHashMap extends AbstractInt2ShortMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2BooleanArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2BooleanArrayMap.java index 1c1a14e..67f1c8f 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2BooleanArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2BooleanOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -61,7 +61,7 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -205,6 +205,27 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B return lastValue; } + @Override + public boolean putFirst(int key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(int key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -319,6 +340,34 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B return result; } + @Override + public Int2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(int key) { int index = findIndex(key); @@ -376,7 +425,7 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -694,24 +743,24 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } @Override - public Int2BooleanMap.Entry first() { + public Int2BooleanMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstBooleanValue()); } @Override - public Int2BooleanMap.Entry last() { + public Int2BooleanMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastBooleanValue()); } @Override - public Int2BooleanMap.Entry pollFirst() { + public Int2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstBooleanValue()); pollFirstIntKey(); return entry; } @Override - public Int2BooleanMap.Entry pollLast() { + public Int2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastBooleanValue()); pollLastIntKey(); return entry; @@ -719,7 +768,12 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -729,7 +783,7 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -926,7 +980,9 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B @Override public boolean moveToLast(int o) { return Int2BooleanArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -934,13 +990,13 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B @Override public void clear() { Int2BooleanArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1037,32 +1093,43 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2BooleanArrayMap.this.size(); - } - + public int size() { return Int2BooleanArrayMap.this.size(); } @Override - public void clear() { - Int2BooleanArrayMap.this.clear(); + public void clear() { Int2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstIntKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1151,10 +1218,8 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2BooleanMap.Entry next() { @@ -1177,11 +1242,8 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2BooleanMap.Entry next() { @@ -1208,11 +1270,8 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1232,6 +1291,9 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1250,23 +1312,37 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1279,26 +1355,42 @@ public class Int2BooleanArrayMap extends AbstractInt2BooleanMap implements Int2B public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ByteArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ByteArrayMap.java index 7df3f1f..744caa2 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ByteArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ByteOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -62,7 +62,7 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd return lastValue; } + @Override + public byte putFirst(int key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(int key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd return result; } + @Override + public Int2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } @Override - public Int2ByteMap.Entry first() { + public Int2ByteMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstByteValue()); } @Override - public Int2ByteMap.Entry last() { + public Int2ByteMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastByteValue()); } @Override - public Int2ByteMap.Entry pollFirst() { + public Int2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstByteValue()); pollFirstIntKey(); return entry; } @Override - public Int2ByteMap.Entry pollLast() { + public Int2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastByteValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd @Override public boolean moveToLast(int o) { return Int2ByteArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd @Override public void clear() { Int2ByteArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ByteArrayMap.this.size(); - } - + public int size() { return Int2ByteArrayMap.this.size(); } @Override - public void clear() { - Int2ByteArrayMap.this.clear(); + public void clear() { Int2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstIntKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2ByteMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2ByteMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2ByteArrayMap extends AbstractInt2ByteMap implements Int2ByteOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2CharArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2CharArrayMap.java index 9a42945..9d3ab62 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2CharArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2CharOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -62,7 +62,7 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd return lastValue; } + @Override + public char putFirst(int key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(int key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd return result; } + @Override + public Int2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } @Override - public Int2CharMap.Entry first() { + public Int2CharMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstCharValue()); } @Override - public Int2CharMap.Entry last() { + public Int2CharMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastCharValue()); } @Override - public Int2CharMap.Entry pollFirst() { + public Int2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstCharValue()); pollFirstIntKey(); return entry; } @Override - public Int2CharMap.Entry pollLast() { + public Int2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastCharValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd @Override public boolean moveToLast(int o) { return Int2CharArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd @Override public void clear() { Int2CharArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2CharArrayMap.this.size(); - } - + public int size() { return Int2CharArrayMap.this.size(); } @Override - public void clear() { - Int2CharArrayMap.this.clear(); + public void clear() { Int2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstIntKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2CharMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2CharMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2CharArrayMap extends AbstractInt2CharMap implements Int2CharOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2DoubleArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2DoubleArrayMap.java index 61917f5..4cf1735 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2DoubleArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2DoubleOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -62,7 +62,7 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou return lastValue; } + @Override + public double putFirst(int key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(int key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou return result; } + @Override + public Int2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } @Override - public Int2DoubleMap.Entry first() { + public Int2DoubleMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstDoubleValue()); } @Override - public Int2DoubleMap.Entry last() { + public Int2DoubleMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastDoubleValue()); } @Override - public Int2DoubleMap.Entry pollFirst() { + public Int2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstDoubleValue()); pollFirstIntKey(); return entry; } @Override - public Int2DoubleMap.Entry pollLast() { + public Int2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastDoubleValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou @Override public boolean moveToLast(int o) { return Int2DoubleArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou @Override public void clear() { Int2DoubleArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2DoubleArrayMap.this.size(); - } - + public int size() { return Int2DoubleArrayMap.this.size(); } @Override - public void clear() { - Int2DoubleArrayMap.this.clear(); + public void clear() { Int2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstIntKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2DoubleMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2DoubleMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2DoubleArrayMap extends AbstractInt2DoubleMap implements Int2Dou public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2FloatArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2FloatArrayMap.java index 6beb9a9..35d0586 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2FloatArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2FloatOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -62,7 +62,7 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float return lastValue; } + @Override + public float putFirst(int key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(int key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float return result; } + @Override + public Int2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } @Override - public Int2FloatMap.Entry first() { + public Int2FloatMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstFloatValue()); } @Override - public Int2FloatMap.Entry last() { + public Int2FloatMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastFloatValue()); } @Override - public Int2FloatMap.Entry pollFirst() { + public Int2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstFloatValue()); pollFirstIntKey(); return entry; } @Override - public Int2FloatMap.Entry pollLast() { + public Int2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastFloatValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float @Override public boolean moveToLast(int o) { return Int2FloatArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float @Override public void clear() { Int2FloatArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2FloatArrayMap.this.size(); - } - + public int size() { return Int2FloatArrayMap.this.size(); } @Override - public void clear() { - Int2FloatArrayMap.this.clear(); + public void clear() { Int2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstIntKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2FloatMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2FloatMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2FloatArrayMap extends AbstractInt2FloatMap implements Int2Float public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2IntArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2IntArrayMap.java index ce199c7..bb49289 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2IntArrayMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2IntOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -55,7 +55,7 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere return lastValue; } + @Override + public int putFirst(int key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(int key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -335,6 +356,34 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere return result; } + @Override + public Int2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(int key) { int index = findIndex(key); @@ -392,7 +441,7 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -710,24 +759,24 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } @Override - public Int2IntMap.Entry first() { + public Int2IntMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstIntValue()); } @Override - public Int2IntMap.Entry last() { + public Int2IntMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastIntValue()); } @Override - public Int2IntMap.Entry pollFirst() { + public Int2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstIntValue()); pollFirstIntKey(); return entry; } @Override - public Int2IntMap.Entry pollLast() { + public Int2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastIntValue()); pollLastIntKey(); return entry; @@ -735,7 +784,12 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -745,7 +799,7 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -942,7 +996,9 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere @Override public boolean moveToLast(int o) { return Int2IntArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -950,13 +1006,13 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere @Override public void clear() { Int2IntArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1053,32 +1109,43 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2IntArrayMap.this.size(); - } - + public int size() { return Int2IntArrayMap.this.size(); } @Override - public void clear() { - Int2IntArrayMap.this.clear(); + public void clear() { Int2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstIntKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1167,10 +1234,8 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2IntMap.Entry next() { @@ -1193,11 +1258,8 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2IntMap.Entry next() { @@ -1224,11 +1286,8 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1248,6 +1307,9 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1266,23 +1328,37 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1295,26 +1371,42 @@ public class Int2IntArrayMap extends AbstractInt2IntMap implements Int2IntOrdere public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2LongArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2LongArrayMap.java index 679fb0c..ab8a521 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2LongArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2LongOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -62,7 +62,7 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd return lastValue; } + @Override + public long putFirst(int key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(int key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd return result; } + @Override + public Int2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } @Override - public Int2LongMap.Entry first() { + public Int2LongMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstLongValue()); } @Override - public Int2LongMap.Entry last() { + public Int2LongMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastLongValue()); } @Override - public Int2LongMap.Entry pollFirst() { + public Int2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstLongValue()); pollFirstIntKey(); return entry; } @Override - public Int2LongMap.Entry pollLast() { + public Int2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastLongValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd @Override public boolean moveToLast(int o) { return Int2LongArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd @Override public void clear() { Int2LongArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2LongArrayMap.this.size(); - } - + public int size() { return Int2LongArrayMap.this.size(); } @Override - public void clear() { - Int2LongArrayMap.this.clear(); + public void clear() { Int2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstIntKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2LongMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2LongMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2LongArrayMap extends AbstractInt2LongMap implements Int2LongOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ObjectArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ObjectArrayMap.java index 2ab9da0..2c2ec33 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ObjectArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ObjectOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -57,7 +57,7 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -201,6 +201,27 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I return lastValue; } + @Override + public V putFirst(int key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(int key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -310,6 +331,34 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I return result; } + @Override + public Int2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Int2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Int2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(int key) { int index = findIndex(key); @@ -367,7 +416,7 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -630,24 +679,24 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } @Override - public Int2ObjectMap.Entry first() { + public Int2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstIntKey(), firstValue()); } @Override - public Int2ObjectMap.Entry last() { + public Int2ObjectMap.Entry getLast() { return new BasicEntry<>(lastIntKey(), lastValue()); } @Override - public Int2ObjectMap.Entry pollFirst() { + public Int2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstIntKey(), firstValue()); pollFirstIntKey(); return entry; } @Override - public Int2ObjectMap.Entry pollLast() { + public Int2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastIntKey(), lastValue()); pollLastIntKey(); return entry; @@ -655,7 +704,12 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -665,7 +719,7 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -862,7 +916,9 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I @Override public boolean moveToLast(int o) { return Int2ObjectArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -870,13 +926,13 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I @Override public void clear() { Int2ObjectArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -973,32 +1029,43 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ObjectArrayMap.this.size(); - } - + public int size() { return Int2ObjectArrayMap.this.size(); } @Override - public void clear() { - Int2ObjectArrayMap.this.clear(); + public void clear() { Int2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstIntKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1087,10 +1154,8 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2ObjectMap.Entry next() { @@ -1113,11 +1178,8 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2ObjectMap.Entry next() { @@ -1144,11 +1206,8 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1168,6 +1227,9 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1186,23 +1248,37 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1215,26 +1291,42 @@ public class Int2ObjectArrayMap extends AbstractInt2ObjectMap implements I public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ShortArrayMap.java b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ShortArrayMap.java index 6045174..926a162 100644 --- a/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/impl/misc/Int2ShortArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.ints.maps.interfaces.Int2ShortOrderedMap; import speiger.src.collections.ints.sets.AbstractIntSet; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -62,7 +62,7 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short /** KeySet cache */ protected IntOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -228,6 +228,27 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short return lastValue; } + @Override + public short putFirst(int key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(int key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(int key) { int index = findIndex(key); @@ -342,6 +363,34 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short return result; } + @Override + public Int2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Int2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Int2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Int2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(int key) { int index = findIndex(key); @@ -399,7 +448,7 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -717,24 +766,24 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } @Override - public Int2ShortMap.Entry first() { + public Int2ShortMap.Entry getFirst() { return new BasicEntry(firstIntKey(), firstShortValue()); } @Override - public Int2ShortMap.Entry last() { + public Int2ShortMap.Entry getLast() { return new BasicEntry(lastIntKey(), lastShortValue()); } @Override - public Int2ShortMap.Entry pollFirst() { + public Int2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstIntKey(), firstShortValue()); pollFirstIntKey(); return entry; } @Override - public Int2ShortMap.Entry pollLast() { + public Int2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastIntKey(), lastShortValue()); pollLastIntKey(); return entry; @@ -742,7 +791,12 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -752,7 +806,7 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -949,7 +1003,9 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short @Override public boolean moveToLast(int o) { return Int2ShortArrayMap.this.moveToLast(o); } @Override - public IntListIterator iterator() { return new KeyIterator(); } + public IntListIterator iterator() { return new KeyIterator(true); } + @Override + public IntListIterator reverseIterator() { return new KeyIterator(false); } @Override public IntBidirectionalIterator iterator(int fromElement) { return new KeyIterator(fromElement); } @Override @@ -957,13 +1013,13 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short @Override public void clear() { Int2ShortArrayMap.this.clear(); } @Override - public int firstInt() { return firstIntKey(); } + public int getFirstInt() { return firstIntKey(); } @Override - public int pollFirstInt() { return pollFirstIntKey(); } + public int removeFirstInt() { return pollFirstIntKey(); } @Override - public int lastInt() { return lastIntKey(); } + public int getLastInt() { return lastIntKey(); } @Override - public int pollLastInt() { return pollLastIntKey(); } + public int removeLastInt() { return pollLastIntKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1060,32 +1116,43 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Int2ShortArrayMap.this.size(); - } - + public int size() { return Int2ShortArrayMap.this.size(); } @Override - public void clear() { - Int2ShortArrayMap.this.clear(); + public void clear() { Int2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstIntKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastIntKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1174,10 +1241,8 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(int from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(int element) { super(element); } @Override public Int2ShortMap.Entry next() { @@ -1200,11 +1265,8 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(int from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(int element) { super(element); } @Override public Int2ShortMap.Entry next() { @@ -1231,11 +1293,8 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } private class KeyIterator extends MapIterator implements IntListIterator { - public KeyIterator() {} - public KeyIterator(int element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(int element) { super(element); } @Override public int previousInt() { @@ -1255,6 +1314,9 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(int element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1273,23 +1335,37 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(int element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1302,26 +1378,42 @@ public class Int2ShortArrayMap extends AbstractInt2ShortMap implements Int2Short public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanMap.java index 1563e52..84e3537 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanMap.java @@ -94,7 +94,7 @@ public interface Int2BooleanMap extends Map, IntPredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanOrderedMap.java index e200220..fc2ec3a 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2BooleanMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2BooleanOrderedMap extends Int2BooleanMap */ public boolean putAndMoveToLast(int key, boolean 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 boolean putFirst(int key, boolean 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 boolean putLast(int key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2BooleanOrderedMap extends Int2BooleanMap */ public boolean lastBooleanValue(); + + public Int2BooleanMap.Entry firstEntry(); + + public Int2BooleanMap.Entry lastEntry(); + + public Int2BooleanMap.Entry pollFirstEntry(); + + public Int2BooleanMap.Entry pollLastEntry(); @Override public Int2BooleanOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet int2BooleanEntrySet(); + public default Int2BooleanOrderedMap reversed() { return new AbstractInt2BooleanMap.ReversedInt2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteMap.java index dc684ac..b411a0f 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteMap.java @@ -94,7 +94,7 @@ public interface Int2ByteMap extends Map, Int2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteOrderedMap.java index 70d5c73..ac03a62 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2ByteMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2ByteOrderedMap extends Int2ByteMap */ public byte putAndMoveToLast(int key, byte 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 byte putFirst(int key, byte 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 byte putLast(int key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2ByteOrderedMap extends Int2ByteMap */ public byte lastByteValue(); + + public Int2ByteMap.Entry firstEntry(); + + public Int2ByteMap.Entry lastEntry(); + + public Int2ByteMap.Entry pollFirstEntry(); + + public Int2ByteMap.Entry pollLastEntry(); @Override public Int2ByteOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet int2ByteEntrySet(); + public default Int2ByteOrderedMap reversed() { return new AbstractInt2ByteMap.ReversedInt2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharMap.java index e693300..4646632 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharMap.java @@ -94,7 +94,7 @@ public interface Int2CharMap extends Map, Int2CharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharOrderedMap.java index a57ec1c..b5632c0 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2CharMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2CharOrderedMap extends Int2CharMap */ public char putAndMoveToLast(int key, char 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 char putFirst(int key, char 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 char putLast(int key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2CharOrderedMap extends Int2CharMap */ public char lastCharValue(); + + public Int2CharMap.Entry firstEntry(); + + public Int2CharMap.Entry lastEntry(); + + public Int2CharMap.Entry pollFirstEntry(); + + public Int2CharMap.Entry pollLastEntry(); @Override public Int2CharOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet int2CharEntrySet(); + public default Int2CharOrderedMap reversed() { return new AbstractInt2CharMap.ReversedInt2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleMap.java index bc34d34..4a52ff6 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleMap.java @@ -94,7 +94,7 @@ public interface Int2DoubleMap extends Map, Int2DoubleFunction * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleOrderedMap.java index 72aec4b..080661e 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2DoubleMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2DoubleOrderedMap extends Int2DoubleMap */ public double putAndMoveToLast(int key, double 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 double putFirst(int key, double 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 double putLast(int key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2DoubleOrderedMap extends Int2DoubleMap */ public double lastDoubleValue(); + + public Int2DoubleMap.Entry firstEntry(); + + public Int2DoubleMap.Entry lastEntry(); + + public Int2DoubleMap.Entry pollFirstEntry(); + + public Int2DoubleMap.Entry pollLastEntry(); @Override public Int2DoubleOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet int2DoubleEntrySet(); + public default Int2DoubleOrderedMap reversed() { return new AbstractInt2DoubleMap.ReversedInt2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatMap.java index 9f6def3..9aca96d 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatMap.java @@ -94,7 +94,7 @@ public interface Int2FloatMap extends Map, Int2FloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatOrderedMap.java index ea441e4..fb26142 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2FloatMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2FloatOrderedMap extends Int2FloatMap */ public float putAndMoveToLast(int key, float 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 float putFirst(int key, float 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 float putLast(int key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2FloatOrderedMap extends Int2FloatMap */ public float lastFloatValue(); + + public Int2FloatMap.Entry firstEntry(); + + public Int2FloatMap.Entry lastEntry(); + + public Int2FloatMap.Entry pollFirstEntry(); + + public Int2FloatMap.Entry pollLastEntry(); @Override public Int2FloatOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet int2FloatEntrySet(); + public default Int2FloatOrderedMap reversed() { return new AbstractInt2FloatMap.ReversedInt2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntMap.java index 9bfae1a..effd9e0 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntMap.java @@ -93,7 +93,7 @@ public interface Int2IntMap extends Map, IntUnaryOperator * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntOrderedMap.java index 4af9c4c..45384f7 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2IntMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2IntOrderedMap extends Int2IntMap */ public int putAndMoveToLast(int key, int 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 int putFirst(int key, int 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 int putLast(int key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2IntOrderedMap extends Int2IntMap */ public int lastIntValue(); + + public Int2IntMap.Entry firstEntry(); + + public Int2IntMap.Entry lastEntry(); + + public Int2IntMap.Entry pollFirstEntry(); + + public Int2IntMap.Entry pollLastEntry(); @Override public Int2IntOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet int2IntEntrySet(); + public default Int2IntOrderedMap reversed() { return new AbstractInt2IntMap.ReversedInt2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongMap.java index 375503d..b639cb6 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongMap.java @@ -94,7 +94,7 @@ public interface Int2LongMap extends Map, Int2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongOrderedMap.java index 1dd63e0..ddf7e53 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2LongMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2LongOrderedMap extends Int2LongMap */ public long putAndMoveToLast(int key, long 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 long putFirst(int key, long 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 long putLast(int key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2LongOrderedMap extends Int2LongMap */ public long lastLongValue(); + + public Int2LongMap.Entry firstEntry(); + + public Int2LongMap.Entry lastEntry(); + + public Int2LongMap.Entry pollFirstEntry(); + + public Int2LongMap.Entry pollLastEntry(); @Override public Int2LongOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet int2LongEntrySet(); + public default Int2LongOrderedMap reversed() { return new AbstractInt2LongMap.ReversedInt2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectMap.java index 3ed30da..62a3fa7 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectMap.java @@ -95,7 +95,7 @@ public interface Int2ObjectMap extends Map, IntFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectOrderedMap.java index 1d761fd..7bee0cf 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2ObjectMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Int2ObjectOrderedMap extends Int2ObjectMap */ public V putAndMoveToLast(int key, V 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 V putFirst(int key, V 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 V putLast(int key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Int2ObjectOrderedMap extends Int2ObjectMap */ public V lastValue(); + + public Int2ObjectMap.Entry firstEntry(); + + public Int2ObjectMap.Entry lastEntry(); + + public Int2ObjectMap.Entry pollFirstEntry(); + + public Int2ObjectMap.Entry pollLastEntry(); @Override public Int2ObjectOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> int2ObjectEntrySet(); + public default Int2ObjectOrderedMap reversed() { return new AbstractInt2ObjectMap.ReversedInt2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortMap.java index 3dafdce..8fc5505 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortMap.java @@ -94,7 +94,7 @@ public interface Int2ShortMap extends Map, Int2ShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().intValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortOrderedMap.java b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortOrderedMap.java index ada1604..817929b 100644 --- a/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/ints/maps/interfaces/Int2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.ints.maps.interfaces; import speiger.src.collections.ints.utils.maps.Int2ShortMaps; +import speiger.src.collections.ints.maps.abstracts.AbstractInt2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Int2ShortOrderedMap extends Int2ShortMap */ public short putAndMoveToLast(int key, short 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 short putFirst(int key, short 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 short putLast(int key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Int2ShortOrderedMap extends Int2ShortMap */ public short lastShortValue(); + + public Int2ShortMap.Entry firstEntry(); + + public Int2ShortMap.Entry lastEntry(); + + public Int2ShortMap.Entry pollFirstEntry(); + + public Int2ShortMap.Entry pollLastEntry(); @Override public Int2ShortOrderedMap copy(); @Override public IntOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet int2ShortEntrySet(); + public default Int2ShortOrderedMap reversed() { return new AbstractInt2ShortMap.ReversedInt2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/sets/AbstractIntSet.java b/src/main/java/speiger/src/collections/ints/sets/AbstractIntSet.java index 5f0433a..e25cecf 100644 --- a/src/main/java/speiger/src/collections/ints/sets/AbstractIntSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/AbstractIntSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.ints.sets; import java.util.Set; import speiger.src.collections.ints.collections.AbstractIntCollection; +import speiger.src.collections.ints.collections.IntBidirectionalIterator; import speiger.src.collections.ints.collections.IntIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractIntSet extends AbstractIntCollection implements In return false; } } + + public static class ReversedIntOrderedSet extends AbstractIntSet implements IntOrderedSet { + protected IntOrderedSet set; + + public ReversedIntOrderedSet(IntOrderedSet set) { + this.set = set; + } + + @Override + public ReversedIntOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public IntBidirectionalIterator iterator(int fromElement) { + return set.iterator(fromElement); + } + + @Override + public IntBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public IntBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(int o) { + return set.remove(o); + } + + @Override + public boolean add(int o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(int o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(int o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(int o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(int o) { + return set.moveToFirst(o); + } + + @Override + public int getFirstInt() { + return set.getLastInt(); + } + + @Override + public int removeFirstInt() { + return set.removeLastInt(); + } + + @Override + public int getLastInt() { + return set.getFirstInt(); + } + + @Override + public int removeLastInt() { + return set.removeFirstInt(); + } + + @Override + public IntOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/ints/sets/ImmutableIntOpenHashSet.java b/src/main/java/speiger/src/collections/ints/sets/ImmutableIntOpenHashSet.java index 3e1fd48..656c868 100644 --- a/src/main/java/speiger/src/collections/ints/sets/ImmutableIntOpenHashSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/ImmutableIntOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere } @Override - public int firstInt() { + public int getFirstInt() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { + public int getLastInt() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere @Override public IntListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere } private class SetIterator implements IntListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(int from) { + this.forward = true; if(from == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere @Override public int previousInt() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableIntOpenHashSet extends AbstractIntSet implements IntOrdere @Override public int nextInt() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/ints/sets/IntArraySet.java b/src/main/java/speiger/src/collections/ints/sets/IntArraySet.java index ddd2d57..919b423 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntArraySet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntArraySet.java @@ -185,13 +185,13 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet } @Override - public int firstInt() { + public int getFirstInt() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public int lastInt() { + public int getLastInt() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -282,7 +282,7 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet } @Override - public int pollFirstInt() { + public int removeFirstInt() { if(size == 0) throw new NoSuchElementException(); int result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -290,7 +290,7 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet } @Override - public int pollLastInt() { + public int removeLastInt() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -413,13 +413,18 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet @Override public IntBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public IntBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public IntBidirectionalIterator iterator(int fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -470,45 +475,57 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet } private class SetIterator implements IntListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public int nextInt() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public int previousInt() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -528,15 +545,23 @@ public class IntArraySet extends AbstractIntSet implements IntOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenCustomHashSet.java index 0dc3351..6b6c988 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public boolean moveToFirst(int o) { - if(isEmpty() || strategy.equals(firstInt(), o)) return false; + if(isEmpty() || strategy.equals(getFirstInt(), o)) return false; if(strategy.equals(o, 0)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public boolean moveToLast(int o) { - if(isEmpty() || strategy.equals(lastInt(), o)) return false; + if(isEmpty() || strategy.equals(getLastInt(), o)) return false; if(strategy.equals(o, 0)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements } @Override - public int firstInt() { + public int getFirstInt() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public int pollFirstInt() { + public int removeFirstInt() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements } @Override - public int lastInt() { + public int getLastInt() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public int pollLastInt() { + public int removeLastInt() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public IntListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements } private class SetIterator implements IntListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(int from) { + this.forward = true; if(strategy.equals(from, 0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public int previousInt() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class IntLinkedOpenCustomHashSet extends IntOpenCustomHashSet implements @Override public int nextInt() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenHashSet.java index fd65c64..00548f5 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public boolean moveToFirst(int o) { - if(isEmpty() || firstInt() == o) return false; + if(isEmpty() || getFirstInt() == o) return false; if(o == 0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public boolean moveToLast(int o) { - if(isEmpty() || lastInt() == o) return false; + if(isEmpty() || getLastInt() == o) return false; if(o == 0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe } @Override - public int firstInt() { + public int getFirstInt() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public int pollFirstInt() { + public int removeFirstInt() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe } @Override - public int lastInt() { + public int getLastInt() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public int pollLastInt() { + public int removeLastInt() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public IntListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public IntListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe } private class SetIterator implements IntListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(int from) { + this.forward = true; if(from == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public int previousInt() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class IntLinkedOpenHashSet extends IntOpenHashSet implements IntOrderedSe @Override public int nextInt() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/ints/sets/IntNavigableSet.java b/src/main/java/speiger/src/collections/ints/sets/IntNavigableSet.java index 244c069..2dbc134 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntNavigableSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.ints.collections.IntBidirectionalIterator; import speiger.src.collections.ints.collections.IntSplititerator; -import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.ints.utils.IntSplititerators; +import speiger.src.collections.ints.utils.IntSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/ints/sets/IntOrderedSet.java b/src/main/java/speiger/src/collections/ints/sets/IntOrderedSet.java index e99d14d..9c9600b 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntOrderedSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.ints.sets; import speiger.src.collections.ints.collections.IntBidirectionalIterator; import speiger.src.collections.ints.collections.IntSplititerator; -import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.ints.utils.IntSplititerators; +import speiger.src.collections.ints.sets.AbstractIntSet.ReversedIntOrderedSet; +import speiger.src.collections.ints.utils.IntSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface IntOrderedSet extends IntSet @Override public IntBidirectionalIterator iterator(); + public IntBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface IntOrderedSet extends IntSet * A method to get the first element in the set * @return first element in the set */ - public int firstInt(); + public int getFirstInt(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public int pollFirstInt(); + public int removeFirstInt(); /** * A method to get the last element in the set * @return last element in the set */ - public int lastInt(); + public int getLastInt(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public int pollLastInt(); + public int removeLastInt(); + + public default IntOrderedSet reversed() { return new ReversedIntOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/ints/sets/IntSet.java b/src/main/java/speiger/src/collections/ints/sets/IntSet.java index d54cea0..a63d712 100644 --- a/src/main/java/speiger/src/collections/ints/sets/IntSet.java +++ b/src/main/java/speiger/src/collections/ints/sets/IntSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.ints.collections.IntCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.collections.IntSplititerator; -import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.ints.utils.IntSplititerators; +import speiger.src.collections.ints.utils.IntSets; /** diff --git a/src/main/java/speiger/src/collections/ints/utils/IntCollections.java b/src/main/java/speiger/src/collections/ints/utils/IntCollections.java index 0474979..84825d7 100644 --- a/src/main/java/speiger/src/collections/ints/utils/IntCollections.java +++ b/src/main/java/speiger/src/collections/ints/utils/IntCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.ints.collections.AbstractIntCollection; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -50,6 +51,34 @@ public class IntCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static IntOrderedCollection unmodifiable(IntOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static IntOrderedCollection synchronize(IntOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static IntOrderedCollection synchronize(IntOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -583,6 +612,37 @@ public class IntCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements IntOrderedCollection { + IntOrderedCollection c; + + SynchronizedOrderedCollection(IntOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(IntOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public IntOrderedCollection reversed() { return IntCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(int e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(int e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public int getFirstInt() { synchronized(mutex) { return this.c.getFirstInt(); } } + @Override + public int removeFirstInt() { synchronized(mutex) { return this.c.removeFirstInt(); } } + @Override + public int getLastInt() { synchronized(mutex) { return this.c.getLastInt(); } } + @Override + public int removeLastInt() { synchronized(mutex) { return this.c.removeLastInt(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -704,6 +764,33 @@ public class IntCollections public int count(IntPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements IntOrderedCollection { + IntOrderedCollection c; + + UnmodifiableOrderedCollection(IntOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public IntOrderedCollection reversed() { return IntCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return c.getFirstInt(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return c.getLastInt(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/ints/utils/IntIterators.java b/src/main/java/speiger/src/collections/ints/utils/IntIterators.java index b5096fd..6262bb7 100644 --- a/src/main/java/speiger/src/collections/ints/utils/IntIterators.java +++ b/src/main/java/speiger/src/collections/ints/utils/IntIterators.java @@ -34,7 +34,7 @@ public class IntIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static IntListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class IntIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(int... a) { + public static IntIterator wrap(int... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class IntIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(int[] a, int start, int end) { + public static IntIterator wrap(int[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/ints/utils/IntLists.java b/src/main/java/speiger/src/collections/ints/utils/IntLists.java index cde1333..106d715 100644 --- a/src/main/java/speiger/src/collections/ints/utils/IntLists.java +++ b/src/main/java/speiger/src/collections/ints/utils/IntLists.java @@ -29,7 +29,7 @@ public class IntLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static IntList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/ints/utils/IntSets.java b/src/main/java/speiger/src/collections/ints/utils/IntSets.java index 0399342..87b8220 100644 --- a/src/main/java/speiger/src/collections/ints/utils/IntSets.java +++ b/src/main/java/speiger/src/collections/ints/utils/IntSets.java @@ -312,17 +312,19 @@ public class IntSets @Override public IntBidirectionalIterator iterator() { return IntIterators.unmodifiable(s.iterator()); } @Override + public IntBidirectionalIterator reverseIterator() { return IntIterators.unmodifiable(s.reverseIterator()); } + @Override public IntBidirectionalIterator iterator(int fromElement) { return IntIterators.unmodifiable(s.iterator(fromElement)); } @Override public IntOrderedSet copy() { return s.copy(); } @Override - public int firstInt() { return s.firstInt(); } + public int getFirstInt() { return s.getFirstInt(); } @Override - public int pollFirstInt() { throw new UnsupportedOperationException(); } + public int removeFirstInt() { throw new UnsupportedOperationException(); } @Override - public int lastInt() { return s.lastInt(); } + public int getLastInt() { return s.getLastInt(); } @Override - public int pollLastInt() { throw new UnsupportedOperationException(); } + public int removeLastInt() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements IntSortedSet @@ -583,17 +585,19 @@ public class IntSets @Override public IntBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public IntBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public IntBidirectionalIterator iterator(int fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public IntOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public int firstInt() { synchronized(mutex) { return s.firstInt(); } } + public int getFirstInt() { synchronized(mutex) { return s.getFirstInt(); } } @Override - public int pollFirstInt() { synchronized(mutex) { return s.pollFirstInt(); } } + public int removeFirstInt() { synchronized(mutex) { return s.removeFirstInt(); } } @Override - public int lastInt() { synchronized(mutex) { return s.lastInt(); } } + public int getLastInt() { synchronized(mutex) { return s.getLastInt(); } } @Override - public int pollLastInt() { synchronized(mutex) { return s.pollLastInt(); } } + public int removeLastInt() { synchronized(mutex) { return s.removeLastInt(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2BooleanMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2BooleanMaps.java index 2213509..16d2e86 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Int2BooleanMaps @Override public boolean putAndMoveToLast(int key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(int key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(int key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Int2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Int2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2BooleanOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet int2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Int2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2BooleanMap.Entry first() { return set.first(); } + public Int2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2BooleanMap.Entry last() { return set.last(); } + public Int2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Int2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Int2BooleanMaps @Override public boolean putAndMoveToLast(int key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(int key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(int key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Int2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Int2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet int2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ByteMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ByteMaps.java index fe794e5..83c87b6 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ByteMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Int2ByteMaps @Override public byte putAndMoveToLast(int key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(int key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(int key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Int2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2ByteOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet int2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Int2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2ByteMap.Entry first() { return set.first(); } + public Int2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ByteMap.Entry last() { return set.last(); } + public Int2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Int2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2ByteMaps @Override public byte putAndMoveToLast(int key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(int key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(int key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Int2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet int2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2CharMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2CharMaps.java index ccef037..eb55285 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2CharMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Int2CharMaps @Override public char putAndMoveToLast(int key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(int key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(int key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Int2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2CharOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet int2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2CharEntrySet()); @@ -617,15 +634,17 @@ public class Int2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2CharMap.Entry first() { return set.first(); } + public Int2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2CharMap.Entry last() { return set.last(); } + public Int2CharMap.Entry getLast() { return set.getLast(); } @Override - public Int2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2CharMaps @Override public char putAndMoveToLast(int key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(int key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(int key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Int2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet int2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2DoubleMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2DoubleMaps.java index 9853a78..2d75347 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Int2DoubleMaps @Override public double putAndMoveToLast(int key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(int key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(int key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Int2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2DoubleOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet int2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Int2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2DoubleMap.Entry first() { return set.first(); } + public Int2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2DoubleMap.Entry last() { return set.last(); } + public Int2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Int2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2DoubleMaps @Override public double putAndMoveToLast(int key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(int key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(int key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Int2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet int2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2FloatMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2FloatMaps.java index d7a416c..0784bd4 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2FloatMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Int2FloatMaps @Override public float putAndMoveToLast(int key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(int key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(int key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Int2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2FloatOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet int2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Int2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2FloatMap.Entry first() { return set.first(); } + public Int2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2FloatMap.Entry last() { return set.last(); } + public Int2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Int2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2FloatMaps @Override public float putAndMoveToLast(int key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(int key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(int key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Int2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet int2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2IntMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2IntMaps.java index becac88..76d0b2a 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2IntMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -438,6 +439,10 @@ public class Int2IntMaps @Override public int putAndMoveToLast(int key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(int key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(int key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Int2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Int2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2IntOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet int2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2IntEntrySet()); @@ -616,15 +633,17 @@ public class Int2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2IntMap.Entry first() { return set.first(); } + public Int2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2IntMap.Entry last() { return set.last(); } + public Int2IntMap.Entry getLast() { return set.getLast(); } @Override - public Int2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Int2IntMaps @Override public int putAndMoveToLast(int key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(int key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(int key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Int2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Int2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet int2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2LongMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2LongMaps.java index 824d5d5..c6ff278 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2LongMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Int2LongMaps @Override public long putAndMoveToLast(int key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(int key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(int key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Int2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2LongOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet int2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2LongEntrySet()); @@ -617,15 +634,17 @@ public class Int2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2LongMap.Entry first() { return set.first(); } + public Int2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2LongMap.Entry last() { return set.last(); } + public Int2LongMap.Entry getLast() { return set.getLast(); } @Override - public Int2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2LongMaps @Override public long putAndMoveToLast(int key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(int key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(int key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Int2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet int2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ObjectMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ObjectMaps.java index 845c626..a610ef1 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Int2ObjectMaps @Override public V putAndMoveToLast(int key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(int key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(int key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Int2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2ObjectOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> int2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.int2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Int2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Int2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2ObjectMap.Entry first() { return set.first(); } + public Int2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ObjectMap.Entry last() { return set.last(); } + public Int2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Int2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Int2ObjectMaps @Override public V putAndMoveToLast(int key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(int key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(int key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Int2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Int2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> int2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ShortMaps.java b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ShortMaps.java index 7b7a92f..14d25b3 100644 --- a/src/main/java/speiger/src/collections/ints/utils/maps/Int2ShortMaps.java +++ b/src/main/java/speiger/src/collections/ints/utils/maps/Int2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.ints.sets.IntOrderedSet; import speiger.src.collections.ints.sets.IntSet; import speiger.src.collections.ints.utils.IntSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Int2ShortMaps @Override public short putAndMoveToLast(int key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(int key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(int key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(int key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(int key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Int2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Int2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Int2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Int2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Int2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Int2ShortOrderedMap copy() { return map.copy(); } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.unmodifiable(map.keySet()); return (IntOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet int2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.int2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Int2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Int2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Int2ShortMap.Entry first() { return set.first(); } + public Int2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Int2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Int2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Int2ShortMap.Entry last() { return set.last(); } + public Int2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Int2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Int2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Int2ShortMaps @Override public short putAndMoveToLast(int key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(int key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(int key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(int key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(int key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Int2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Int2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Int2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Int2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Int2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Int2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public IntOrderedSet keySet() { if(keys == null) keys = IntSets.synchronize(map.keySet(), mutex); return (IntOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet int2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.int2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/collections/AbstractLongCollection.java b/src/main/java/speiger/src/collections/longs/collections/AbstractLongCollection.java index 5653686..66037bc 100644 --- a/src/main/java/speiger/src/collections/longs/collections/AbstractLongCollection.java +++ b/src/main/java/speiger/src/collections/longs/collections/AbstractLongCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.longs.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.longs.lists.LongListIterator; import speiger.src.collections.longs.functions.LongConsumer; import speiger.src.collections.longs.utils.LongIterators; import speiger.src.collections.longs.utils.LongArrays; @@ -249,4 +251,68 @@ public abstract class AbstractLongCollection extends AbstractCollection im if (a.length > size()) a[size()] = 0L; return a; } + + public static class ReverseLongOrderedCollection extends AbstractLongCollection implements LongOrderedCollection { + LongOrderedCollection collection; + Supplier reverseIterator; + + public ReverseLongOrderedCollection(LongOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(long o) { return collection.add(o); } + @Override + public LongOrderedCollection reversed() { return collection; } + @Override + public void addFirst(long e) { collection.addLast(e); } + @Override + public void addLast(long e) { collection.addFirst(e); } + @Override + public boolean contains(long e) { return collection.contains(e); } + @Override + public boolean remLong(long e) { return collection.remLong(e); } + @Override + public void clear() { collection.clear(); } + @Override + public long getFirstLong() { return collection.getLastLong(); } + @Override + public long removeFirstLong() { return collection.removeLastLong(); } + @Override + public long getLastLong() { return collection.getFirstLong(); } + @Override + public long removeLastLong() { return collection.removeFirstLong(); } + @Override + public LongIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements LongListIterator { + LongListIterator it; + + public ReverseBiIterator(LongListIterator it) { + this.it = it; + } + + @Override + public long nextLong() { return it.previousLong(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public long previousLong() { return it.nextLong(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(long e) { it.set(e); } + @Override + public void add(long e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/longs/collections/LongBidirectionalIterator.java b/src/main/java/speiger/src/collections/longs/collections/LongBidirectionalIterator.java index e9d759f..f29d04d 100644 --- a/src/main/java/speiger/src/collections/longs/collections/LongBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/longs/collections/LongBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.longs.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface LongBidirectionalIterator extends LongIterator, ObjectBidirectionalIterator +public interface LongBidirectionalIterator extends LongIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface LongBidirectionalIterator extends LongIterator, ObjectBidirecti */ public long previousLong(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Long previous() { return Long.valueOf(previousLong()); diff --git a/src/main/java/speiger/src/collections/longs/collections/LongOrderedCollection.java b/src/main/java/speiger/src/collections/longs/collections/LongOrderedCollection.java new file mode 100644 index 0000000..bc05101 --- /dev/null +++ b/src/main/java/speiger/src/collections/longs/collections/LongOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.longs.collections; + +public interface LongOrderedCollection extends LongCollection { + + LongOrderedCollection 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(long 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(long e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public long getFirstLong(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public long removeFirstLong(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public long getLastLong(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public long removeLastLong(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/longs/lists/AbstractLongList.java b/src/main/java/speiger/src/collections/longs/lists/AbstractLongList.java index 7eaad53..676cc4f 100644 --- a/src/main/java/speiger/src/collections/longs/lists/AbstractLongList.java +++ b/src/main/java/speiger/src/collections/longs/lists/AbstractLongList.java @@ -466,7 +466,6 @@ public abstract class AbstractLongList extends AbstractLongCollection implements public int size() { return size; } - @Override public LongSplititerator spliterator() { return LongSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/longs/lists/LongLinkedList.java b/src/main/java/speiger/src/collections/longs/lists/LongLinkedList.java index 073ff98..24bdbdc 100644 --- a/src/main/java/speiger/src/collections/longs/lists/LongLinkedList.java +++ b/src/main/java/speiger/src/collections/longs/lists/LongLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.longs.functions.LongConsumer; import speiger.src.collections.longs.utils.LongArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.LongStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.longs.collections.LongSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.longs.collections.LongSplititerator; import speiger.src.collections.longs.utils.LongSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class LongLinkedList extends AbstractLongList implements LongPriorityDequ if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class LongLinkedList extends AbstractLongList implements LongPriorityDequ * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public LongStream parallelPrimitiveStream() { return StreamSupport.longStream(new SplitIterator(this, first, 0), true); } - /** + public LongStream parallelPrimitiveStream() { return StreamSupport.longStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/longs/lists/LongList.java b/src/main/java/speiger/src/collections/longs/lists/LongList.java index 084424d..3cb40e9 100644 --- a/src/main/java/speiger/src/collections/longs/lists/LongList.java +++ b/src/main/java/speiger/src/collections/longs/lists/LongList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongSplititerator; import speiger.src.collections.ints.functions.consumer.IntLongConsumer; import speiger.src.collections.longs.functions.LongComparator; @@ -20,7 +21,7 @@ import speiger.src.collections.longs.utils.LongSplititerators; /** * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features */ -public interface LongList extends LongCollection, List +public interface LongList extends LongOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -83,6 +84,24 @@ public interface LongList extends LongCollection, List */ public boolean addAll(int index, LongList 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(long 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(long e) { + add(e); + } + /** * 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. @@ -413,9 +432,9 @@ public interface LongList extends LongCollection, List @Override @Deprecated public default boolean add(Long e) { - return LongCollection.super.add(e); + return LongOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -463,7 +482,7 @@ public interface LongList extends LongCollection, List @Override @Deprecated public default boolean contains(Object o) { - return LongCollection.super.contains(o); + return LongOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -473,7 +492,7 @@ public interface LongList extends LongCollection, List @Override @Deprecated public default boolean remove(Object o) { - return LongCollection.super.remove(o); + return LongOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2BooleanMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2BooleanMap.java index b2c51bd..bb45f7e 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2BooleanMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.consumer.LongBooleanConsumer; import speiger.src.collections.longs.functions.function.LongBooleanUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2BooleanMap; +import speiger.src.collections.longs.maps.interfaces.Long2BooleanOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractLong2BooleanMap extends AbstractMap public void putAll(Long[] keys, Boolean[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedLong2BooleanOrderedMap extends AbstractLong2BooleanMap implements Long2BooleanOrderedMap { + Long2BooleanOrderedMap map; + + public ReversedLong2BooleanOrderedMap(Long2BooleanOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2BooleanMap setDefaultReturnValue(boolean v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public boolean getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2BooleanOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public boolean put(long key, boolean value) { return map.put(key, value); } + @Override + public boolean putIfAbsent(long key, boolean value) { return map.putIfAbsent(key, value); } + @Override + public boolean remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, boolean value) { return map.remove(key, value); } + @Override + public boolean removeOrDefault(long key, boolean defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(boolean value) { return map.containsValue(value); } + @Override + public boolean replace(long key, boolean oldValue, boolean newValue) { return map.replace(key, oldValue, newValue); } + @Override + public boolean replace(long key, boolean value) { return map.replace(key, value); } + @Override + public void replaceBooleans(Long2BooleanMap m) { map.replaceBooleans(m); } + @Override + public void replaceBooleans(LongBooleanUnaryOperator mappingFunction) { map.replaceBooleans(mappingFunction); } + @Override + public boolean computeBoolean(long key, LongBooleanUnaryOperator mappingFunction) { return map.computeBoolean(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsent(long key, LongPredicate mappingFunction) { return map.computeBooleanIfAbsent(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsent(long key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsent(key, valueProvider); } + @Override + public boolean computeBooleanIfPresent(long key, LongBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresent(key, mappingFunction); } + @Override + public boolean computeBooleanNonDefault(long key, LongBooleanUnaryOperator mappingFunction) { return map.computeBooleanNonDefault(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsentNonDefault(long key, LongPredicate mappingFunction) { return map.computeBooleanIfAbsentNonDefault(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsentNonDefault(long key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsentNonDefault(key, valueProvider); } + @Override + public boolean computeBooleanIfPresentNonDefault(long key, LongBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresentNonDefault(key, mappingFunction); } + @Override + public boolean mergeBoolean(long key, boolean value, BooleanBooleanUnaryOperator mappingFunction) { return map.mergeBoolean(key, value, mappingFunction); } + @Override + public boolean getOrDefault(long key, boolean defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public boolean get(long key) { return map.get(key); } + @Override + public boolean putAndMoveToFirst(long key, boolean value) { return map.putAndMoveToLast(key, value); } + @Override + public boolean putAndMoveToLast(long key, boolean value) { return map.putAndMoveToFirst(key, value); } + @Override + public boolean putFirst(long key, boolean value) { return map.putLast(key, value); } + @Override + public boolean putLast(long key, boolean value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public boolean getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public boolean getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public boolean firstBooleanValue() { return map.lastBooleanValue(); } + @Override + public boolean lastBooleanValue() { return map.firstBooleanValue(); } + @Override + public Long2BooleanMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2BooleanMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2BooleanMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2BooleanMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2BooleanEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ByteMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ByteMap.java index cd4b188..5644882 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ByteMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongByteConsumer; import speiger.src.collections.longs.functions.function.Long2ByteFunction; import speiger.src.collections.longs.functions.function.LongByteUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2ByteMap; +import speiger.src.collections.longs.maps.interfaces.Long2ByteOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2ByteMap extends AbstractMap implements Long2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2ByteMap extends AbstractMap imple public void putAll(Long[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imple return hash; } + public static class ReversedLong2ByteOrderedMap extends AbstractLong2ByteMap implements Long2ByteOrderedMap { + Long2ByteOrderedMap map; + + public ReversedLong2ByteOrderedMap(Long2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(long key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(long key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(long key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(long key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(long key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(long key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(long key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Long2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(LongByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(long key, LongByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(long key, Long2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(long key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(long key, LongByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(long key, LongByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(long key, Long2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(long key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(long key, LongByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(long key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(long key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(long key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(long key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(long key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(long key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(long key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Long2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2ByteEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2CharMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2CharMap.java index a1d9393..0f367c6 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2CharMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongCharConsumer; import speiger.src.collections.longs.functions.function.Long2CharFunction; import speiger.src.collections.longs.functions.function.LongCharUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2CharMap; +import speiger.src.collections.longs.maps.interfaces.Long2CharOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2CharMap extends AbstractMap implements Long2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2CharMap extends AbstractMap public void putAll(Long[] keys, Character[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedLong2CharOrderedMap extends AbstractLong2CharMap implements Long2CharOrderedMap { + Long2CharOrderedMap map; + + public ReversedLong2CharOrderedMap(Long2CharOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2CharMap setDefaultReturnValue(char v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public char getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2CharOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public char put(long key, char value) { return map.put(key, value); } + @Override + public char putIfAbsent(long key, char value) { return map.putIfAbsent(key, value); } + @Override + public char addTo(long key, char value) { return map.addTo(key, value); } + @Override + public char subFrom(long key, char value) { return map.subFrom(key, value); } + @Override + public char remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, char value) { return map.remove(key, value); } + @Override + public char removeOrDefault(long key, char defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(char value) { return map.containsValue(value); } + @Override + public boolean replace(long key, char oldValue, char newValue) { return map.replace(key, oldValue, newValue); } + @Override + public char replace(long key, char value) { return map.replace(key, value); } + @Override + public void replaceChars(Long2CharMap m) { map.replaceChars(m); } + @Override + public void replaceChars(LongCharUnaryOperator mappingFunction) { map.replaceChars(mappingFunction); } + @Override + public char computeChar(long key, LongCharUnaryOperator mappingFunction) { return map.computeChar(key, mappingFunction); } + @Override + public char computeCharIfAbsent(long key, Long2CharFunction mappingFunction) { return map.computeCharIfAbsent(key, mappingFunction); } + @Override + public char supplyCharIfAbsent(long key, CharSupplier valueProvider) { return map.supplyCharIfAbsent(key, valueProvider); } + @Override + public char computeCharIfPresent(long key, LongCharUnaryOperator mappingFunction) { return map.computeCharIfPresent(key, mappingFunction); } + @Override + public char computeCharNonDefault(long key, LongCharUnaryOperator mappingFunction) { return map.computeCharNonDefault(key, mappingFunction); } + @Override + public char computeCharIfAbsentNonDefault(long key, Long2CharFunction mappingFunction) { return map.computeCharIfAbsentNonDefault(key, mappingFunction); } + @Override + public char supplyCharIfAbsentNonDefault(long key, CharSupplier valueProvider) { return map.supplyCharIfAbsentNonDefault(key, valueProvider); } + @Override + public char computeCharIfPresentNonDefault(long key, LongCharUnaryOperator mappingFunction) { return map.computeCharIfPresentNonDefault(key, mappingFunction); } + @Override + public char mergeChar(long key, char value, CharCharUnaryOperator mappingFunction) { return map.mergeChar(key, value, mappingFunction); } + @Override + public char getOrDefault(long key, char defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public char get(long key) { return map.get(key); } + @Override + public char putAndMoveToFirst(long key, char value) { return map.putAndMoveToLast(key, value); } + @Override + public char putAndMoveToLast(long key, char value) { return map.putAndMoveToFirst(key, value); } + @Override + public char putFirst(long key, char value) { return map.putLast(key, value); } + @Override + public char putLast(long key, char value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public char getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public char getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public char firstCharValue() { return map.lastCharValue(); } + @Override + public char lastCharValue() { return map.firstCharValue(); } + @Override + public Long2CharMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2CharMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2CharMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2CharMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2CharEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2DoubleMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2DoubleMap.java index 3c5b1ff..d3a7981 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2DoubleMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongDoubleConsumer; import speiger.src.collections.longs.functions.function.Long2DoubleFunction; import speiger.src.collections.longs.functions.function.LongDoubleUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2DoubleMap; +import speiger.src.collections.longs.maps.interfaces.Long2DoubleOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2DoubleMap extends AbstractMap implements Long2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2DoubleMap extends AbstractMap i public void putAll(Long[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedLong2DoubleOrderedMap extends AbstractLong2DoubleMap implements Long2DoubleOrderedMap { + Long2DoubleOrderedMap map; + + public ReversedLong2DoubleOrderedMap(Long2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(long key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(long key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(long key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(long key, double value) { return map.subFrom(key, value); } + @Override + public double remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, double value) { return map.remove(key, value); } + @Override + public double removeOrDefault(long key, double defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(long key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(long key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Long2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(LongDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(long key, LongDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(long key, Long2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(long key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(long key, LongDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(long key, LongDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(long key, Long2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(long key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(long key, LongDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(long key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(long key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double get(long key) { return map.get(key); } + @Override + public double putAndMoveToFirst(long key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(long key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(long key, double value) { return map.putLast(key, value); } + @Override + public double putLast(long key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Long2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2DoubleEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2FloatMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2FloatMap.java index 8088982..fbc4b36 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2FloatMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongFloatConsumer; import speiger.src.collections.longs.functions.function.Long2FloatFunction; import speiger.src.collections.longs.functions.function.LongFloatUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2FloatMap; +import speiger.src.collections.longs.maps.interfaces.Long2FloatOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2FloatMap extends AbstractMap implements Long2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2FloatMap extends AbstractMap imp public void putAll(Long[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedLong2FloatOrderedMap extends AbstractLong2FloatMap implements Long2FloatOrderedMap { + Long2FloatOrderedMap map; + + public ReversedLong2FloatOrderedMap(Long2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(long key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(long key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(long key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(long key, float value) { return map.subFrom(key, value); } + @Override + public float remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(long key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(long key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(long key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Long2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(LongFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(long key, LongFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(long key, Long2FloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(long key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(long key, LongFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(long key, LongFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(long key, Long2FloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(long key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(long key, LongFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(long key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(long key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(long key) { return map.get(key); } + @Override + public float putAndMoveToFirst(long key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(long key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(long key, float value) { return map.putLast(key, value); } + @Override + public float putLast(long key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Long2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2FloatEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2IntMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2IntMap.java index 6c0262d..b13b6cf 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2IntMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongIntConsumer; import speiger.src.collections.longs.functions.function.Long2IntFunction; import speiger.src.collections.longs.functions.function.LongIntUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2IntMap; +import speiger.src.collections.longs.maps.interfaces.Long2IntOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2IntMap extends AbstractMap implements Long2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2IntMap extends AbstractMap imp public void putAll(Long[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedLong2IntOrderedMap extends AbstractLong2IntMap implements Long2IntOrderedMap { + Long2IntOrderedMap map; + + public ReversedLong2IntOrderedMap(Long2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(long key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(long key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(long key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(long key, int value) { return map.subFrom(key, value); } + @Override + public int remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(long key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(long key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(long key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Long2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(LongIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(long key, LongIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(long key, Long2IntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(long key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(long key, LongIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(long key, LongIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(long key, Long2IntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(long key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(long key, LongIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(long key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(long key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(long key) { return map.get(key); } + @Override + public int putAndMoveToFirst(long key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(long key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(long key, int value) { return map.putLast(key, value); } + @Override + public int putLast(long key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Long2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2IntEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2LongMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2LongMap.java index 5739423..10a304e 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2LongMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongLongConsumer; import speiger.src.collections.longs.functions.function.LongUnaryOperator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2LongMap; +import speiger.src.collections.longs.maps.interfaces.Long2LongOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2LongMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2LongMap extends AbstractMap implements Long2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractLong2LongMap extends AbstractMap imple public void putAll(Long[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imple return hash; } + public static class ReversedLong2LongOrderedMap extends AbstractLong2LongMap implements Long2LongOrderedMap { + Long2LongOrderedMap map; + + public ReversedLong2LongOrderedMap(Long2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(long key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(long key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(long key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(long key, long value) { return map.subFrom(key, value); } + @Override + public long remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(long key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(long key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(long key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Long2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(LongLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(long key, LongLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(long key, LongUnaryOperator mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(long key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(long key, LongLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(long key, LongLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(long key, LongUnaryOperator mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(long key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(long key, LongLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(long key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(long key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(long key) { return map.get(key); } + @Override + public long putAndMoveToFirst(long key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(long key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(long key, long value) { return map.putLast(key, value); } + @Override + public long putLast(long key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Long2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2LongEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ObjectMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ObjectMap.java index bb862ff..b118688 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ObjectMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongObjectConsumer; import speiger.src.collections.longs.functions.function.LongFunction; import speiger.src.collections.longs.functions.function.LongObjectUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2ObjectMap; +import speiger.src.collections.longs.maps.interfaces.Long2ObjectOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractLong2ObjectMap extends AbstractMap imp public void putAll(Long[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap imp return hash; } + public static class ReversedLong2ObjectOrderedMap extends AbstractLong2ObjectMap implements Long2ObjectOrderedMap { + Long2ObjectOrderedMap map; + + public ReversedLong2ObjectOrderedMap(Long2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(long key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(long key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(long key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(long key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(long key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Long2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(LongObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(long key, LongObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(long key, LongFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(long key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(long key, LongObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(long key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(long key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(long key) { return map.get(key); } + @Override + public V putAndMoveToFirst(long key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(long key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(long key, V value) { return map.putLast(key, value); } + @Override + public V putLast(long key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Long2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> long2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2ObjectEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ShortMap.java b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ShortMap.java index cb42028..5deace7 100644 --- a/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ShortMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/abstracts/AbstractLong2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.longs.functions.consumer.LongShortConsumer; import speiger.src.collections.longs.functions.function.Long2ShortFunction; import speiger.src.collections.longs.functions.function.LongShortUnaryOperator; import speiger.src.collections.longs.maps.interfaces.Long2ShortMap; +import speiger.src.collections.longs.maps.interfaces.Long2ShortOrderedMap; +import speiger.src.collections.longs.sets.LongOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.maps.Long2ShortMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractLong2ShortMap extends AbstractMap implements Long2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractLong2ShortMap extends AbstractMap imp public void putAll(Long[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedLong2ShortOrderedMap extends AbstractLong2ShortMap implements Long2ShortOrderedMap { + Long2ShortOrderedMap map; + + public ReversedLong2ShortOrderedMap(Long2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractLong2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Long2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(long key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(long key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(long key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(long key, short value) { return map.subFrom(key, value); } + @Override + public short remove(long key) { return map.remove(key); } + @Override + public boolean remove(long key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(long key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(long key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(long key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(long key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Long2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(LongShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(long key, LongShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(long key, Long2ShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(long key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(long key, LongShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(long key, LongShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(long key, Long2ShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(long key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(long key, LongShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(long key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(long key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(long key) { return map.get(key); } + @Override + public short putAndMoveToFirst(long key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(long key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(long key, short value) { return map.putLast(key, value); } + @Override + public short putLast(long key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(long key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(long key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(long key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(long key) { return map.getAndMoveToFirst(key); } + @Override + public long firstLongKey() { return map.lastLongKey(); } + @Override + public long pollFirstLongKey() { return map.pollLastLongKey(); } + @Override + public long lastLongKey() { return map.firstLongKey(); } + @Override + public long pollLastLongKey() { return map.pollFirstLongKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Long2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Long2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Long2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Long2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet long2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.long2ShortEntrySet()); } + @Override + public LongOrderedSet keySet() { return new AbstractLongSet.ReversedLongOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Long2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2BooleanLinkedOpenCustomHashMap.java index bfd2fd5..30cfa5d 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH return getDefaultReturnValue(); } + @Override + public boolean putFirst(long key, boolean value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 boolean putLast(long key, boolean value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH return values[lastIndex]; } + @Override + public Long2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } @Override - public Long2BooleanMap.Entry first() { + public Long2BooleanMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstBooleanValue()); } @Override - public Long2BooleanMap.Entry last() { + public Long2BooleanMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastBooleanValue()); } @Override - public Long2BooleanMap.Entry pollFirst() { + public Long2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstBooleanValue()); pollFirstLongKey(); return entry; } @Override - public Long2BooleanMap.Entry pollLast() { + public Long2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastBooleanValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstLongKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Long2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2BooleanLinkedOpenCustomHashMap extends Long2BooleanOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ByteLinkedOpenCustomHashMap.java index 4258559..400bb4f 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ByteLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -258,6 +258,54 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public byte putFirst(long key, byte value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 byte putLast(long key, byte value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap return values[lastIndex]; } + @Override + public Long2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } @Override - public Long2ByteMap.Entry first() { + public Long2ByteMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstByteValue()); } @Override - public Long2ByteMap.Entry last() { + public Long2ByteMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastByteValue()); } @Override - public Long2ByteMap.Entry pollFirst() { + public Long2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstByteValue()); pollFirstLongKey(); return entry; } @Override - public Long2ByteMap.Entry pollLast() { + public Long2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastByteValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstLongKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Long2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1284,16 +1399,20 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2ByteLinkedOpenCustomHashMap extends Long2ByteOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2CharLinkedOpenCustomHashMap.java index 2b547bd..4076180 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2CharLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -258,6 +258,54 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public char putFirst(long key, char value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 char putLast(long key, char value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap return values[lastIndex]; } + @Override + public Long2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } @Override - public Long2CharMap.Entry first() { + public Long2CharMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstCharValue()); } @Override - public Long2CharMap.Entry last() { + public Long2CharMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastCharValue()); } @Override - public Long2CharMap.Entry pollFirst() { + public Long2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstCharValue()); pollFirstLongKey(); return entry; } @Override - public Long2CharMap.Entry pollLast() { + public Long2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastCharValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstLongKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Long2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1284,16 +1399,20 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2CharLinkedOpenCustomHashMap extends Long2CharOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2DoubleLinkedOpenCustomHashMap.java index 0aafa7b..00aa676 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2DoubleLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -258,6 +258,54 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas return getDefaultReturnValue(); } + @Override + public double putFirst(long key, double value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 double putLast(long key, double value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas return values[lastIndex]; } + @Override + public Long2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } @Override - public Long2DoubleMap.Entry first() { + public Long2DoubleMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstDoubleValue()); } @Override - public Long2DoubleMap.Entry last() { + public Long2DoubleMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastDoubleValue()); } @Override - public Long2DoubleMap.Entry pollFirst() { + public Long2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstDoubleValue()); pollFirstLongKey(); return entry; } @Override - public Long2DoubleMap.Entry pollLast() { + public Long2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastDoubleValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstLongKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Long2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1284,16 +1399,20 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2DoubleLinkedOpenCustomHashMap extends Long2DoubleOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2FloatLinkedOpenCustomHashMap.java index 6333eeb..fdcaf42 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2FloatLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -258,6 +258,54 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM return getDefaultReturnValue(); } + @Override + public float putFirst(long key, float value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 float putLast(long key, float value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM return values[lastIndex]; } + @Override + public Long2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } @Override - public Long2FloatMap.Entry first() { + public Long2FloatMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstFloatValue()); } @Override - public Long2FloatMap.Entry last() { + public Long2FloatMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastFloatValue()); } @Override - public Long2FloatMap.Entry pollFirst() { + public Long2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstFloatValue()); pollFirstLongKey(); return entry; } @Override - public Long2FloatMap.Entry pollLast() { + public Long2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastFloatValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstLongKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Long2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1284,16 +1399,20 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2FloatLinkedOpenCustomHashMap extends Long2FloatOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2IntLinkedOpenCustomHashMap.java index 4e0d4ed..a1c320c 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i return getDefaultReturnValue(); } + @Override + public int putFirst(long key, int value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 int putLast(long key, int value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i return values[lastIndex]; } + @Override + public Long2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } @Override - public Long2IntMap.Entry first() { + public Long2IntMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstIntValue()); } @Override - public Long2IntMap.Entry last() { + public Long2IntMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastIntValue()); } @Override - public Long2IntMap.Entry pollFirst() { + public Long2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstIntValue()); pollFirstLongKey(); return entry; } @Override - public Long2IntMap.Entry pollLast() { + public Long2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastIntValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstLongKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Long2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2IntLinkedOpenCustomHashMap extends Long2IntOpenCustomHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2LongLinkedOpenCustomHashMap.java index 58d5128..79c24ad 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2LongLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public long putFirst(long key, long value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 long putLast(long key, long value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -386,6 +434,52 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap return values[lastIndex]; } + @Override + public Long2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } @Override - public Long2LongMap.Entry first() { + public Long2LongMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstLongValue()); } @Override - public Long2LongMap.Entry last() { + public Long2LongMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastLongValue()); } @Override - public Long2LongMap.Entry pollFirst() { + public Long2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstLongValue()); pollFirstLongKey(); return entry; } @Override - public Long2LongMap.Entry pollLast() { + public Long2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastLongValue()); pollLastLongKey(); return entry; @@ -611,7 +705,12 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1023,30 +1127,41 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstLongKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Long2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastLongKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1204,7 +1319,7 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1234,7 +1349,7 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1256,7 +1371,7 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1277,16 +1392,20 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Long2LongLinkedOpenCustomHashMap extends Long2LongOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ObjectLinkedOpenCustomHashMap.java index 4530af3..cdf7aef 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom return getDefaultReturnValue(); } + @Override + public V putFirst(long key, V value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 V putLast(long key, V value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -388,6 +436,52 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom return values[lastIndex]; } + @Override + public Long2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> long2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } @Override - public Long2ObjectMap.Entry first() { + public Long2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstLongKey(), firstValue()); } @Override - public Long2ObjectMap.Entry last() { + public Long2ObjectMap.Entry getLast() { return new BasicEntry<>(lastLongKey(), lastValue()); } @Override - public Long2ObjectMap.Entry pollFirst() { + public Long2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstLongKey(), firstValue()); pollFirstLongKey(); return entry; } @Override - public Long2ObjectMap.Entry pollLast() { + public Long2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastLongKey(), lastValue()); pollLastLongKey(); return entry; @@ -613,7 +707,12 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,31 +1129,42 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Long2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Long2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Long2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstLongKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastLongKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Long2ObjectLinkedOpenCustomHashMap extends Long2ObjectOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ShortLinkedOpenCustomHashMap.java index 24de259..8283cba 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/customHash/Long2ShortLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.utils.LongStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -258,6 +258,54 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM return getDefaultReturnValue(); } + @Override + public short putFirst(long key, short value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + 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 short putLast(long key, short value) { + if(strategy.equals(key, 0L)) { + 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], 0L)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || strategy.equals(firstLongKey(), key)) return false; @@ -393,6 +441,52 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM return values[lastIndex]; } + @Override + public Long2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getLongKey(), 0L)) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } @Override - public Long2ShortMap.Entry first() { + public Long2ShortMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstShortValue()); } @Override - public Long2ShortMap.Entry last() { + public Long2ShortMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastShortValue()); } @Override - public Long2ShortMap.Entry pollFirst() { + public Long2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstShortValue()); pollFirstLongKey(); return entry; } @Override - public Long2ShortMap.Entry pollLast() { + public Long2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastShortValue()); pollLastLongKey(); return entry; @@ -618,7 +712,12 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1030,30 +1134,41 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Long2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Long2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstLongKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Long2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Long2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastLongKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1211,7 +1326,7 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1241,7 +1356,7 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1263,7 +1378,7 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1284,16 +1399,20 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Long2ShortLinkedOpenCustomHashMap extends Long2ShortOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2BooleanLinkedOpenHashMap.java index b79cc17..3b4d6b2 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2BooleanOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple return getDefaultReturnValue(); } + @Override + public boolean putFirst(long key, boolean value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 boolean putLast(long key, boolean value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple return values[lastIndex]; } + @Override + public Long2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } @Override - public Long2BooleanMap.Entry first() { + public Long2BooleanMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstBooleanValue()); } @Override - public Long2BooleanMap.Entry last() { + public Long2BooleanMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastBooleanValue()); } @Override - public Long2BooleanMap.Entry pollFirst() { + public Long2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstBooleanValue()); pollFirstLongKey(); return entry; } @Override - public Long2BooleanMap.Entry pollLast() { + public Long2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastBooleanValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Long2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstLongKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2BooleanLinkedOpenHashMap extends Long2BooleanOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ByteLinkedOpenHashMap.java index 7f305b3..79b716d 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ByteLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ByteOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -235,6 +235,54 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements return getDefaultReturnValue(); } + @Override + public byte putFirst(long key, byte value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 byte putLast(long key, byte value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements return values[lastIndex]; } + @Override + public Long2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } @Override - public Long2ByteMap.Entry first() { + public Long2ByteMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstByteValue()); } @Override - public Long2ByteMap.Entry last() { + public Long2ByteMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastByteValue()); } @Override - public Long2ByteMap.Entry pollFirst() { + public Long2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstByteValue()); pollFirstLongKey(); return entry; } @Override - public Long2ByteMap.Entry pollLast() { + public Long2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastByteValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Long2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstLongKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1279,13 +1394,16 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2ByteLinkedOpenHashMap extends Long2ByteOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2CharLinkedOpenHashMap.java index 3f2f9dc..c1becaf 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2CharLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2CharOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -235,6 +235,54 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements return getDefaultReturnValue(); } + @Override + public char putFirst(long key, char value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 char putLast(long key, char value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements return values[lastIndex]; } + @Override + public Long2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } @Override - public Long2CharMap.Entry first() { + public Long2CharMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstCharValue()); } @Override - public Long2CharMap.Entry last() { + public Long2CharMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastCharValue()); } @Override - public Long2CharMap.Entry pollFirst() { + public Long2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstCharValue()); pollFirstLongKey(); return entry; } @Override - public Long2CharMap.Entry pollLast() { + public Long2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastCharValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2CharLinkedOpenHashMap.this.clear(); + public void clear() { Long2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstLongKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1279,13 +1394,16 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2CharLinkedOpenHashMap extends Long2CharOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2DoubleLinkedOpenHashMap.java index a1893e6..7c9a676 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2DoubleLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2DoubleOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -235,6 +235,54 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public double putFirst(long key, double value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 double putLast(long key, double value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme return values[lastIndex]; } + @Override + public Long2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } @Override - public Long2DoubleMap.Entry first() { + public Long2DoubleMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstDoubleValue()); } @Override - public Long2DoubleMap.Entry last() { + public Long2DoubleMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastDoubleValue()); } @Override - public Long2DoubleMap.Entry pollFirst() { + public Long2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstDoubleValue()); pollFirstLongKey(); return entry; } @Override - public Long2DoubleMap.Entry pollLast() { + public Long2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastDoubleValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Long2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstLongKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1279,13 +1394,16 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2DoubleLinkedOpenHashMap extends Long2DoubleOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2FloatLinkedOpenHashMap.java index 22a87dd..724e413 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2FloatLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2FloatOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -235,6 +235,54 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement return getDefaultReturnValue(); } + @Override + public float putFirst(long key, float value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 float putLast(long key, float value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement return values[lastIndex]; } + @Override + public Long2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } @Override - public Long2FloatMap.Entry first() { + public Long2FloatMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstFloatValue()); } @Override - public Long2FloatMap.Entry last() { + public Long2FloatMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastFloatValue()); } @Override - public Long2FloatMap.Entry pollFirst() { + public Long2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstFloatValue()); pollFirstLongKey(); return entry; } @Override - public Long2FloatMap.Entry pollLast() { + public Long2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastFloatValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Long2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstLongKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1279,13 +1394,16 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2FloatLinkedOpenHashMap extends Long2FloatOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2IntLinkedOpenHashMap.java index 0eda6b7..9e82c21 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2IntOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo return getDefaultReturnValue(); } + @Override + public int putFirst(long key, int value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 int putLast(long key, int value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo return values[lastIndex]; } + @Override + public Long2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } @Override - public Long2IntMap.Entry first() { + public Long2IntMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstIntValue()); } @Override - public Long2IntMap.Entry last() { + public Long2IntMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastIntValue()); } @Override - public Long2IntMap.Entry pollFirst() { + public Long2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstIntValue()); pollFirstLongKey(); return entry; } @Override - public Long2IntMap.Entry pollLast() { + public Long2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastIntValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2IntLinkedOpenHashMap.this.clear(); + public void clear() { Long2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstLongKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2IntLinkedOpenHashMap extends Long2IntOpenHashMap implements Lo public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2LongLinkedOpenHashMap.java index 93cb83a..b6f30d8 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2LongLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2LongOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements return getDefaultReturnValue(); } + @Override + public long putFirst(long key, long value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 long putLast(long key, long value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -384,6 +432,52 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements return values[lastIndex]; } + @Override + public Long2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } @Override - public Long2LongMap.Entry first() { + public Long2LongMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstLongValue()); } @Override - public Long2LongMap.Entry last() { + public Long2LongMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastLongValue()); } @Override - public Long2LongMap.Entry pollFirst() { + public Long2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstLongValue()); pollFirstLongKey(); return entry; } @Override - public Long2LongMap.Entry pollLast() { + public Long2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastLongValue()); pollLastLongKey(); return entry; @@ -609,7 +703,12 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1018,32 +1122,43 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2LongLinkedOpenHashMap.this.clear(); + public void clear() { Long2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstLongKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1200,7 +1315,7 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1230,7 +1345,7 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1252,7 +1367,7 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1272,13 +1387,16 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1309,11 +1427,11 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Long2LongLinkedOpenHashMap extends Long2LongOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ObjectLinkedOpenHashMap.java index 36a1a2c..b17cc4a 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ObjectOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i return getDefaultReturnValue(); } + @Override + public V putFirst(long key, V value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 V putLast(long key, V value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -375,6 +423,52 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i return values[lastIndex]; } + @Override + public Long2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> long2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } @Override - public Long2ObjectMap.Entry first() { + public Long2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstLongKey(), firstValue()); } @Override - public Long2ObjectMap.Entry last() { + public Long2ObjectMap.Entry getLast() { return new BasicEntry<>(lastLongKey(), lastValue()); } @Override - public Long2ObjectMap.Entry pollFirst() { + public Long2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstLongKey(), firstValue()); pollFirstLongKey(); return entry; } @Override - public Long2ObjectMap.Entry pollLast() { + public Long2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastLongKey(), lastValue()); pollLastLongKey(); return entry; @@ -600,7 +694,12 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1009,33 +1113,44 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Long2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstLongKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1192,7 +1307,7 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1222,7 +1337,7 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1244,7 +1359,7 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1301,11 +1419,11 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Long2ObjectLinkedOpenHashMap extends Long2ObjectOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ShortLinkedOpenHashMap.java index b8da165..d63506e 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/hash/Long2ShortLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ShortOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -235,6 +235,54 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement return getDefaultReturnValue(); } + @Override + public short putFirst(long key, short value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(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 short putLast(long key, short value) { + if(key == 0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Long.hashCode(key)) & mask; + while(key == 0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(long key) { if(isEmpty() || firstLongKey() == key) return false; @@ -391,6 +439,52 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement return values[lastIndex]; } + @Override + public Long2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Long2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getLongKey() == 0) { + containsNull = false; + keys[nullIndex] = 0L; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet long2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } @Override - public Long2ShortMap.Entry first() { + public Long2ShortMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstShortValue()); } @Override - public Long2ShortMap.Entry last() { + public Long2ShortMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastShortValue()); } @Override - public Long2ShortMap.Entry pollFirst() { + public Long2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstShortValue()); pollFirstLongKey(); return entry; } @Override - public Long2ShortMap.Entry pollLast() { + public Long2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastShortValue()); pollLastLongKey(); return entry; @@ -616,7 +710,12 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { + public long removeLastLong() { return pollLastLongKey(); } @@ -1025,32 +1129,43 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Long2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Long2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Long2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstLongKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1207,7 +1322,7 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1237,7 +1352,7 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1259,7 +1374,7 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1279,13 +1394,16 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1316,11 +1434,11 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Long2ShortLinkedOpenHashMap extends Long2ShortOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2BooleanOpenHashMap.java index e15f55d..5b84b36 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im @Override public boolean putAndMoveToLast(long key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(long key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(long key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im public boolean moveToLast(Long2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2BooleanMap.Entry first() { + public Long2BooleanMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstBooleanValue()); } @Override - public Long2BooleanMap.Entry last() { + public Long2BooleanMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastBooleanValue()); } @Override - public Long2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1211,11 +1250,11 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableLong2BooleanOpenHashMap extends AbstractLong2BooleanMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ByteOpenHashMap.java index 216e7ff..aa3202c 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ByteOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen @Override public byte putAndMoveToLast(long key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(long key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(long key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2ByteEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen public boolean moveToLast(Long2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2ByteMap.Entry first() { + public Long2ByteMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstByteValue()); } @Override - public Long2ByteMap.Entry last() { + public Long2ByteMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastByteValue()); } @Override - public Long2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2ByteOpenHashMap extends AbstractLong2ByteMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2CharOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2CharOpenHashMap.java index 0f0697c..298e402 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2CharOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen @Override public char putAndMoveToLast(long key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(long key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(long key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2CharEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen public boolean moveToLast(Long2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2CharMap.Entry first() { + public Long2CharMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstCharValue()); } @Override - public Long2CharMap.Entry last() { + public Long2CharMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastCharValue()); } @Override - public Long2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2CharOpenHashMap extends AbstractLong2CharMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2DoubleOpenHashMap.java index daeb313..4a1ad16 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2DoubleOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl @Override public double putAndMoveToLast(long key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(long key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(long key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2DoubleEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl public boolean moveToLast(Long2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2DoubleMap.Entry first() { + public Long2DoubleMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstDoubleValue()); } @Override - public Long2DoubleMap.Entry last() { + public Long2DoubleMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastDoubleValue()); } @Override - public Long2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2DoubleOpenHashMap extends AbstractLong2DoubleMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2FloatOpenHashMap.java index 31f3de1..0bbd1aa 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2FloatOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem @Override public float putAndMoveToLast(long key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(long key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(long key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2FloatEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem public boolean moveToLast(Long2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2FloatMap.Entry first() { + public Long2FloatMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstFloatValue()); } @Override - public Long2FloatMap.Entry last() { + public Long2FloatMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastFloatValue()); } @Override - public Long2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2FloatOpenHashMap extends AbstractLong2FloatMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2IntOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2IntOpenHashMap.java index f4e6e03..4407c32 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements @Override public int putAndMoveToLast(long key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(long key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(long key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements public boolean moveToLast(Long2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2IntMap.Entry first() { + public Long2IntMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstIntValue()); } @Override - public Long2IntMap.Entry last() { + public Long2IntMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastIntValue()); } @Override - public Long2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2IntOpenHashMap extends AbstractLong2IntMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2LongOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2LongOpenHashMap.java index bcb3bd3..a686e0e 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2LongOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.longs.utils.LongArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen @Override public long putAndMoveToLast(long key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(long key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(long key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2LongEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen public boolean moveToLast(Long2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2LongMap.Entry first() { + public Long2LongMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstLongValue()); } @Override - public Long2LongMap.Entry last() { + public Long2LongMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastLongValue()); } @Override - public Long2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1170,13 +1206,16 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1207,11 +1246,11 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableLong2LongOpenHashMap extends AbstractLong2LongMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ObjectOpenHashMap.java index ed9c4cf..18022c0 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> long2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap o) { throw new UnsupportedOperationException(); } @Override - public Long2ObjectMap.Entry first() { + public Long2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstLongKey(), firstValue()); } @Override - public Long2ObjectMap.Entry last() { + public Long2ObjectMap.Entry getLast() { return new BasicEntry<>(lastLongKey(), lastValue()); } @Override - public Long2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableLong2ObjectOpenHashMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap extends AbstractLong2ObjectMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ShortOpenHashMap.java index b95b6a8..abe8532 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/immutable/ImmutableLong2ShortOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem /** KeySet cache */ protected transient LongOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem @Override public short putAndMoveToLast(long key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(long key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(long key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Long2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Long2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Long2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet long2ShortEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem public boolean moveToLast(Long2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Long2ShortMap.Entry first() { + public Long2ShortMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstShortValue()); } @Override - public Long2ShortMap.Entry last() { + public Long2ShortMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastShortValue()); } @Override - public Long2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem @Override public LongListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public long firstLong() { + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableLong2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableLong2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(long from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(long from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(long from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1179,13 +1215,16 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(long from) { @@ -1216,11 +1255,11 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableLong2ShortOpenHashMap extends AbstractLong2ShortMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2BooleanArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2BooleanArrayMap.java index d3f06a6..38f31de 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2BooleanOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon return lastValue; } + @Override + public boolean putFirst(long key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(long key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon return result; } + @Override + public Long2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(long key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } @Override - public Long2BooleanMap.Entry first() { + public Long2BooleanMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstBooleanValue()); } @Override - public Long2BooleanMap.Entry last() { + public Long2BooleanMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastBooleanValue()); } @Override - public Long2BooleanMap.Entry pollFirst() { + public Long2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstBooleanValue()); pollFirstLongKey(); return entry; } @Override - public Long2BooleanMap.Entry pollLast() { + public Long2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastBooleanValue()); pollLastLongKey(); return entry; @@ -720,7 +769,12 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon @Override public boolean moveToLast(long o) { return Long2BooleanArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon @Override public void clear() { Long2BooleanArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2BooleanArrayMap.this.size(); - } - + public int size() { return Long2BooleanArrayMap.this.size(); } @Override - public void clear() { - Long2BooleanArrayMap.this.clear(); + public void clear() { Long2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstLongKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1233,6 +1292,9 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Long2BooleanArrayMap extends AbstractLong2BooleanMap implements Lon public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ByteArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ByteArrayMap.java index e065688..4a7fab3 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ByteArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ByteOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -63,7 +63,7 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte return lastValue; } + @Override + public byte putFirst(long key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(long key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte return result; } + @Override + public Long2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } @Override - public Long2ByteMap.Entry first() { + public Long2ByteMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstByteValue()); } @Override - public Long2ByteMap.Entry last() { + public Long2ByteMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastByteValue()); } @Override - public Long2ByteMap.Entry pollFirst() { + public Long2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstByteValue()); pollFirstLongKey(); return entry; } @Override - public Long2ByteMap.Entry pollLast() { + public Long2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastByteValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte @Override public boolean moveToLast(long o) { return Long2ByteArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte @Override public void clear() { Long2ByteArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ByteArrayMap.this.size(); - } - + public int size() { return Long2ByteArrayMap.this.size(); } @Override - public void clear() { - Long2ByteArrayMap.this.clear(); + public void clear() { Long2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstLongKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2ByteMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2ByteMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2ByteArrayMap extends AbstractLong2ByteMap implements Long2Byte public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2CharArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2CharArrayMap.java index 78e8629..9f74804 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2CharArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2CharOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -63,7 +63,7 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char return lastValue; } + @Override + public char putFirst(long key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(long key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char return result; } + @Override + public Long2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } @Override - public Long2CharMap.Entry first() { + public Long2CharMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstCharValue()); } @Override - public Long2CharMap.Entry last() { + public Long2CharMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastCharValue()); } @Override - public Long2CharMap.Entry pollFirst() { + public Long2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstCharValue()); pollFirstLongKey(); return entry; } @Override - public Long2CharMap.Entry pollLast() { + public Long2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastCharValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char @Override public boolean moveToLast(long o) { return Long2CharArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char @Override public void clear() { Long2CharArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2CharArrayMap.this.size(); - } - + public int size() { return Long2CharArrayMap.this.size(); } @Override - public void clear() { - Long2CharArrayMap.this.clear(); + public void clear() { Long2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstLongKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2CharMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2CharMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2CharArrayMap extends AbstractLong2CharMap implements Long2Char public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2DoubleArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2DoubleArrayMap.java index 699fc3c..11eed4c 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2DoubleArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2DoubleOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -63,7 +63,7 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 return lastValue; } + @Override + public double putFirst(long key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(long key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 return result; } + @Override + public Long2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } @Override - public Long2DoubleMap.Entry first() { + public Long2DoubleMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstDoubleValue()); } @Override - public Long2DoubleMap.Entry last() { + public Long2DoubleMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastDoubleValue()); } @Override - public Long2DoubleMap.Entry pollFirst() { + public Long2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstDoubleValue()); pollFirstLongKey(); return entry; } @Override - public Long2DoubleMap.Entry pollLast() { + public Long2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastDoubleValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 @Override public boolean moveToLast(long o) { return Long2DoubleArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 @Override public void clear() { Long2DoubleArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2DoubleArrayMap.this.size(); - } - + public int size() { return Long2DoubleArrayMap.this.size(); } @Override - public void clear() { - Long2DoubleArrayMap.this.clear(); + public void clear() { Long2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstLongKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2DoubleMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2DoubleMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2DoubleArrayMap extends AbstractLong2DoubleMap implements Long2 public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2FloatArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2FloatArrayMap.java index 736b305..cb33721 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2FloatArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2FloatOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -63,7 +63,7 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl return lastValue; } + @Override + public float putFirst(long key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(long key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl return result; } + @Override + public Long2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } @Override - public Long2FloatMap.Entry first() { + public Long2FloatMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstFloatValue()); } @Override - public Long2FloatMap.Entry last() { + public Long2FloatMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastFloatValue()); } @Override - public Long2FloatMap.Entry pollFirst() { + public Long2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstFloatValue()); pollFirstLongKey(); return entry; } @Override - public Long2FloatMap.Entry pollLast() { + public Long2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastFloatValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl @Override public boolean moveToLast(long o) { return Long2FloatArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl @Override public void clear() { Long2FloatArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2FloatArrayMap.this.size(); - } - + public int size() { return Long2FloatArrayMap.this.size(); } @Override - public void clear() { - Long2FloatArrayMap.this.clear(); + public void clear() { Long2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstLongKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2FloatMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2FloatMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2FloatArrayMap extends AbstractLong2FloatMap implements Long2Fl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2IntArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2IntArrayMap.java index 52071b3..ac1a5fd 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2IntOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd return lastValue; } + @Override + public int putFirst(long key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(long key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd return result; } + @Override + public Long2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } @Override - public Long2IntMap.Entry first() { + public Long2IntMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstIntValue()); } @Override - public Long2IntMap.Entry last() { + public Long2IntMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastIntValue()); } @Override - public Long2IntMap.Entry pollFirst() { + public Long2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstIntValue()); pollFirstLongKey(); return entry; } @Override - public Long2IntMap.Entry pollLast() { + public Long2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastIntValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd @Override public boolean moveToLast(long o) { return Long2IntArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd @Override public void clear() { Long2IntArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2IntArrayMap.this.size(); - } - + public int size() { return Long2IntArrayMap.this.size(); } @Override - public void clear() { - Long2IntArrayMap.this.clear(); + public void clear() { Long2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstLongKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2IntArrayMap extends AbstractLong2IntMap implements Long2IntOrd public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2LongArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2LongArrayMap.java index 360b542..adef5d2 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2LongArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2LongOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long return lastValue; } + @Override + public long putFirst(long key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(long key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long return result; } + @Override + public Long2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(long key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } @Override - public Long2LongMap.Entry first() { + public Long2LongMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstLongValue()); } @Override - public Long2LongMap.Entry last() { + public Long2LongMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastLongValue()); } @Override - public Long2LongMap.Entry pollFirst() { + public Long2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstLongValue()); pollFirstLongKey(); return entry; } @Override - public Long2LongMap.Entry pollLast() { + public Long2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastLongValue()); pollLastLongKey(); return entry; @@ -736,7 +785,12 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long @Override public boolean moveToLast(long o) { return Long2LongArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long @Override public void clear() { Long2LongArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2LongArrayMap.this.size(); - } - + public int size() { return Long2LongArrayMap.this.size(); } @Override - public void clear() { - Long2LongArrayMap.this.clear(); + public void clear() { Long2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstLongKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2LongMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2LongMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1249,6 +1308,9 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Long2LongArrayMap extends AbstractLong2LongMap implements Long2Long public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ObjectArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ObjectArrayMap.java index 11721db..644f338 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ObjectOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements return lastValue; } + @Override + public V putFirst(long key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(long key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements return result; } + @Override + public Long2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Long2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Long2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(long key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } @Override - public Long2ObjectMap.Entry first() { + public Long2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstLongKey(), firstValue()); } @Override - public Long2ObjectMap.Entry last() { + public Long2ObjectMap.Entry getLast() { return new BasicEntry<>(lastLongKey(), lastValue()); } @Override - public Long2ObjectMap.Entry pollFirst() { + public Long2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstLongKey(), firstValue()); pollFirstLongKey(); return entry; } @Override - public Long2ObjectMap.Entry pollLast() { + public Long2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastLongKey(), lastValue()); pollLastLongKey(); return entry; @@ -656,7 +705,12 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements @Override public boolean moveToLast(long o) { return Long2ObjectArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements @Override public void clear() { Long2ObjectArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ObjectArrayMap.this.size(); - } - + public int size() { return Long2ObjectArrayMap.this.size(); } @Override - public void clear() { - Long2ObjectArrayMap.this.clear(); + public void clear() { Long2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstLongKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1169,6 +1228,9 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Long2ObjectArrayMap extends AbstractLong2ObjectMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ShortArrayMap.java b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ShortArrayMap.java index 40bddf8..f2525b7 100644 --- a/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/impl/misc/Long2ShortArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.longs.maps.interfaces.Long2ShortOrderedMap; import speiger.src.collections.longs.sets.AbstractLongSet; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -63,7 +63,7 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh /** KeySet cache */ protected LongOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh return lastValue; } + @Override + public short putFirst(long key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(long key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(long key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh return result; } + @Override + public Long2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Long2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Long2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Long2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(long key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } @Override - public Long2ShortMap.Entry first() { + public Long2ShortMap.Entry getFirst() { return new BasicEntry(firstLongKey(), firstShortValue()); } @Override - public Long2ShortMap.Entry last() { + public Long2ShortMap.Entry getLast() { return new BasicEntry(lastLongKey(), lastShortValue()); } @Override - public Long2ShortMap.Entry pollFirst() { + public Long2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstLongKey(), firstShortValue()); pollFirstLongKey(); return entry; } @Override - public Long2ShortMap.Entry pollLast() { + public Long2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastLongKey(), lastShortValue()); pollLastLongKey(); return entry; @@ -743,7 +792,12 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh @Override public boolean moveToLast(long o) { return Long2ShortArrayMap.this.moveToLast(o); } @Override - public LongListIterator iterator() { return new KeyIterator(); } + public LongListIterator iterator() { return new KeyIterator(true); } + @Override + public LongListIterator reverseIterator() { return new KeyIterator(false); } @Override public LongBidirectionalIterator iterator(long fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh @Override public void clear() { Long2ShortArrayMap.this.clear(); } @Override - public long firstLong() { return firstLongKey(); } + public long getFirstLong() { return firstLongKey(); } @Override - public long pollFirstLong() { return pollFirstLongKey(); } + public long removeFirstLong() { return pollFirstLongKey(); } @Override - public long lastLong() { return lastLongKey(); } + public long getLastLong() { return lastLongKey(); } @Override - public long pollLastLong() { return pollLastLongKey(); } + public long removeLastLong() { return pollLastLongKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Long2ShortArrayMap.this.size(); - } - + public int size() { return Long2ShortArrayMap.this.size(); } @Override - public void clear() { - Long2ShortArrayMap.this.clear(); + public void clear() { Long2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstLongKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastLongKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(long from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(long element) { super(element); } @Override public Long2ShortMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(long from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(long element) { super(element); } @Override public Long2ShortMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } private class KeyIterator extends MapIterator implements LongListIterator { - public KeyIterator() {} - public KeyIterator(long element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(long element) { super(element); } @Override public long previousLong() { @@ -1256,6 +1315,9 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(long element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(long element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Long2ShortArrayMap extends AbstractLong2ShortMap implements Long2Sh public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanMap.java index 97f1e07..2491ec5 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanMap.java @@ -94,7 +94,7 @@ public interface Long2BooleanMap extends Map, LongPredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanOrderedMap.java index ef058ad..462a5ad 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2BooleanMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2BooleanOrderedMap extends Long2BooleanMap */ public boolean putAndMoveToLast(long key, boolean 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 boolean putFirst(long key, boolean 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 boolean putLast(long key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2BooleanOrderedMap extends Long2BooleanMap */ public boolean lastBooleanValue(); + + public Long2BooleanMap.Entry firstEntry(); + + public Long2BooleanMap.Entry lastEntry(); + + public Long2BooleanMap.Entry pollFirstEntry(); + + public Long2BooleanMap.Entry pollLastEntry(); @Override public Long2BooleanOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet long2BooleanEntrySet(); + public default Long2BooleanOrderedMap reversed() { return new AbstractLong2BooleanMap.ReversedLong2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteMap.java index d059c04..59aeb9f 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteMap.java @@ -94,7 +94,7 @@ public interface Long2ByteMap extends Map, Long2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteOrderedMap.java index da759aa..de8be75 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2ByteMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2ByteOrderedMap extends Long2ByteMap */ public byte putAndMoveToLast(long key, byte 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 byte putFirst(long key, byte 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 byte putLast(long key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2ByteOrderedMap extends Long2ByteMap */ public byte lastByteValue(); + + public Long2ByteMap.Entry firstEntry(); + + public Long2ByteMap.Entry lastEntry(); + + public Long2ByteMap.Entry pollFirstEntry(); + + public Long2ByteMap.Entry pollLastEntry(); @Override public Long2ByteOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet long2ByteEntrySet(); + public default Long2ByteOrderedMap reversed() { return new AbstractLong2ByteMap.ReversedLong2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharMap.java index 19796cb..06153ad 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharMap.java @@ -94,7 +94,7 @@ public interface Long2CharMap extends Map, Long2CharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharOrderedMap.java index ff12b82..e53dd0f 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2CharMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2CharOrderedMap extends Long2CharMap */ public char putAndMoveToLast(long key, char 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 char putFirst(long key, char 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 char putLast(long key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2CharOrderedMap extends Long2CharMap */ public char lastCharValue(); + + public Long2CharMap.Entry firstEntry(); + + public Long2CharMap.Entry lastEntry(); + + public Long2CharMap.Entry pollFirstEntry(); + + public Long2CharMap.Entry pollLastEntry(); @Override public Long2CharOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet long2CharEntrySet(); + public default Long2CharOrderedMap reversed() { return new AbstractLong2CharMap.ReversedLong2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleMap.java index 59d3b70..7991578 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleMap.java @@ -94,7 +94,7 @@ public interface Long2DoubleMap extends Map, Long2DoubleFunction * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleOrderedMap.java index ed498a7..b281bd4 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2DoubleMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2DoubleOrderedMap extends Long2DoubleMap */ public double putAndMoveToLast(long key, double 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 double putFirst(long key, double 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 double putLast(long key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2DoubleOrderedMap extends Long2DoubleMap */ public double lastDoubleValue(); + + public Long2DoubleMap.Entry firstEntry(); + + public Long2DoubleMap.Entry lastEntry(); + + public Long2DoubleMap.Entry pollFirstEntry(); + + public Long2DoubleMap.Entry pollLastEntry(); @Override public Long2DoubleOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet long2DoubleEntrySet(); + public default Long2DoubleOrderedMap reversed() { return new AbstractLong2DoubleMap.ReversedLong2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatMap.java index fc653cb..26ba0c5 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatMap.java @@ -94,7 +94,7 @@ public interface Long2FloatMap extends Map, Long2FloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatOrderedMap.java index 2e4d534..f969847 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2FloatMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2FloatOrderedMap extends Long2FloatMap */ public float putAndMoveToLast(long key, float 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 float putFirst(long key, float 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 float putLast(long key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2FloatOrderedMap extends Long2FloatMap */ public float lastFloatValue(); + + public Long2FloatMap.Entry firstEntry(); + + public Long2FloatMap.Entry lastEntry(); + + public Long2FloatMap.Entry pollFirstEntry(); + + public Long2FloatMap.Entry pollLastEntry(); @Override public Long2FloatOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet long2FloatEntrySet(); + public default Long2FloatOrderedMap reversed() { return new AbstractLong2FloatMap.ReversedLong2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntMap.java index 4e20d93..8ee62a3 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntMap.java @@ -94,7 +94,7 @@ public interface Long2IntMap extends Map, Long2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntOrderedMap.java index 5bc34a3..cc3cb6f 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2IntMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2IntOrderedMap extends Long2IntMap */ public int putAndMoveToLast(long key, int 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 int putFirst(long key, int 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 int putLast(long key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2IntOrderedMap extends Long2IntMap */ public int lastIntValue(); + + public Long2IntMap.Entry firstEntry(); + + public Long2IntMap.Entry lastEntry(); + + public Long2IntMap.Entry pollFirstEntry(); + + public Long2IntMap.Entry pollLastEntry(); @Override public Long2IntOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet long2IntEntrySet(); + public default Long2IntOrderedMap reversed() { return new AbstractLong2IntMap.ReversedLong2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongMap.java index e718d46..d71fa25 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongMap.java @@ -93,7 +93,7 @@ public interface Long2LongMap extends Map, LongUnaryOperator * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongOrderedMap.java index 70091b0..24aaa1a 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2LongMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2LongOrderedMap extends Long2LongMap */ public long putAndMoveToLast(long key, long 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 long putFirst(long key, long 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 long putLast(long key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2LongOrderedMap extends Long2LongMap */ public long lastLongValue(); + + public Long2LongMap.Entry firstEntry(); + + public Long2LongMap.Entry lastEntry(); + + public Long2LongMap.Entry pollFirstEntry(); + + public Long2LongMap.Entry pollLastEntry(); @Override public Long2LongOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet long2LongEntrySet(); + public default Long2LongOrderedMap reversed() { return new AbstractLong2LongMap.ReversedLong2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectMap.java index 7248840..c679f22 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectMap.java @@ -95,7 +95,7 @@ public interface Long2ObjectMap extends Map, LongFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectOrderedMap.java index 620e029..4251ee2 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2ObjectMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Long2ObjectOrderedMap extends Long2ObjectMap */ public V putAndMoveToLast(long key, V 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 V putFirst(long key, V 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 V putLast(long key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Long2ObjectOrderedMap extends Long2ObjectMap */ public V lastValue(); + + public Long2ObjectMap.Entry firstEntry(); + + public Long2ObjectMap.Entry lastEntry(); + + public Long2ObjectMap.Entry pollFirstEntry(); + + public Long2ObjectMap.Entry pollLastEntry(); @Override public Long2ObjectOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> long2ObjectEntrySet(); + public default Long2ObjectOrderedMap reversed() { return new AbstractLong2ObjectMap.ReversedLong2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortMap.java index 012d79e..3a63754 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortMap.java @@ -94,7 +94,7 @@ public interface Long2ShortMap extends Map, Long2ShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().longValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortOrderedMap.java b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortOrderedMap.java index 125b241..d25d899 100644 --- a/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/longs/maps/interfaces/Long2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.longs.maps.interfaces; import speiger.src.collections.longs.utils.maps.Long2ShortMaps; +import speiger.src.collections.longs.maps.abstracts.AbstractLong2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Long2ShortOrderedMap extends Long2ShortMap */ public short putAndMoveToLast(long key, short 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 short putFirst(long key, short 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 short putLast(long key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Long2ShortOrderedMap extends Long2ShortMap */ public short lastShortValue(); + + public Long2ShortMap.Entry firstEntry(); + + public Long2ShortMap.Entry lastEntry(); + + public Long2ShortMap.Entry pollFirstEntry(); + + public Long2ShortMap.Entry pollLastEntry(); @Override public Long2ShortOrderedMap copy(); @Override public LongOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet long2ShortEntrySet(); + public default Long2ShortOrderedMap reversed() { return new AbstractLong2ShortMap.ReversedLong2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/sets/AbstractLongSet.java b/src/main/java/speiger/src/collections/longs/sets/AbstractLongSet.java index 22c4ff1..95d07d8 100644 --- a/src/main/java/speiger/src/collections/longs/sets/AbstractLongSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/AbstractLongSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.longs.sets; import java.util.Set; import speiger.src.collections.longs.collections.AbstractLongCollection; +import speiger.src.collections.longs.collections.LongBidirectionalIterator; import speiger.src.collections.longs.collections.LongIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractLongSet extends AbstractLongCollection implements return false; } } + + public static class ReversedLongOrderedSet extends AbstractLongSet implements LongOrderedSet { + protected LongOrderedSet set; + + public ReversedLongOrderedSet(LongOrderedSet set) { + this.set = set; + } + + @Override + public ReversedLongOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public LongBidirectionalIterator iterator(long fromElement) { + return set.iterator(fromElement); + } + + @Override + public LongBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public LongBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(long o) { + return set.remove(o); + } + + @Override + public boolean add(long o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(long o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(long o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(long o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(long o) { + return set.moveToFirst(o); + } + + @Override + public long getFirstLong() { + return set.getLastLong(); + } + + @Override + public long removeFirstLong() { + return set.removeLastLong(); + } + + @Override + public long getLastLong() { + return set.getFirstLong(); + } + + @Override + public long removeLastLong() { + return set.removeFirstLong(); + } + + @Override + public LongOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/longs/sets/ImmutableLongOpenHashSet.java b/src/main/java/speiger/src/collections/longs/sets/ImmutableLongOpenHashSet.java index 18f1875..151adcc 100644 --- a/src/main/java/speiger/src/collections/longs/sets/ImmutableLongOpenHashSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/ImmutableLongOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd } @Override - public long firstLong() { + public long getFirstLong() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { + public long getLastLong() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd @Override public LongListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd } private class SetIterator implements LongListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(long from) { + this.forward = true; if(from == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd @Override public long previousLong() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableLongOpenHashSet extends AbstractLongSet implements LongOrd @Override public long nextLong() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/longs/sets/LongArraySet.java b/src/main/java/speiger/src/collections/longs/sets/LongArraySet.java index 2a468ce..59dddc4 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongArraySet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongArraySet.java @@ -185,13 +185,13 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet } @Override - public long firstLong() { + public long getFirstLong() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public long lastLong() { + public long getLastLong() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -282,7 +282,7 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet } @Override - public long pollFirstLong() { + public long removeFirstLong() { if(size == 0) throw new NoSuchElementException(); long result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -290,7 +290,7 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet } @Override - public long pollLastLong() { + public long removeLastLong() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -413,13 +413,18 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet @Override public LongBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public LongBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public LongBidirectionalIterator iterator(long fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -470,45 +475,57 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet } private class SetIterator implements LongListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public long nextLong() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public long previousLong() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -528,15 +545,23 @@ public class LongArraySet extends AbstractLongSet implements LongOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenCustomHashSet.java index 2d992d4..10995d5 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public boolean moveToFirst(long o) { - if(isEmpty() || strategy.equals(firstLong(), o)) return false; + if(isEmpty() || strategy.equals(getFirstLong(), o)) return false; if(strategy.equals(o, 0L)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public boolean moveToLast(long o) { - if(isEmpty() || strategy.equals(lastLong(), o)) return false; + if(isEmpty() || strategy.equals(getLastLong(), o)) return false; if(strategy.equals(o, 0L)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement } @Override - public long firstLong() { + public long getFirstLong() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public long pollFirstLong() { + public long removeFirstLong() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement } @Override - public long lastLong() { + public long getLastLong() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public long pollLastLong() { + public long removeLastLong() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public LongListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement } private class SetIterator implements LongListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(long from) { + this.forward = true; if(strategy.equals(from, 0L)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public long previousLong() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class LongLinkedOpenCustomHashSet extends LongOpenCustomHashSet implement @Override public long nextLong() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenHashSet.java index c33ca55..5d7aca3 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public boolean moveToFirst(long o) { - if(isEmpty() || firstLong() == o) return false; + if(isEmpty() || getFirstLong() == o) return false; if(o == 0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public boolean moveToLast(long o) { - if(isEmpty() || lastLong() == o) return false; + if(isEmpty() || getLastLong() == o) return false; if(o == 0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere } @Override - public long firstLong() { + public long getFirstLong() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public long pollFirstLong() { + public long removeFirstLong() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere } @Override - public long lastLong() { + public long getLastLong() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public long pollLastLong() { + public long removeLastLong() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public LongListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public LongListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere } private class SetIterator implements LongListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(long from) { + this.forward = true; if(from == 0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public long previousLong() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class LongLinkedOpenHashSet extends LongOpenHashSet implements LongOrdere @Override public long nextLong() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/longs/sets/LongNavigableSet.java b/src/main/java/speiger/src/collections/longs/sets/LongNavigableSet.java index 8b25e8e..56cdcac 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongNavigableSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.longs.collections.LongBidirectionalIterator; import speiger.src.collections.longs.collections.LongSplititerator; -import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.longs.utils.LongSplititerators; +import speiger.src.collections.longs.utils.LongSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/longs/sets/LongOrderedSet.java b/src/main/java/speiger/src/collections/longs/sets/LongOrderedSet.java index 451e5b1..d21ceff 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongOrderedSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.longs.sets; import speiger.src.collections.longs.collections.LongBidirectionalIterator; import speiger.src.collections.longs.collections.LongSplititerator; -import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.longs.utils.LongSplititerators; +import speiger.src.collections.longs.sets.AbstractLongSet.ReversedLongOrderedSet; +import speiger.src.collections.longs.utils.LongSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface LongOrderedSet extends LongSet @Override public LongBidirectionalIterator iterator(); + public LongBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface LongOrderedSet extends LongSet * A method to get the first element in the set * @return first element in the set */ - public long firstLong(); + public long getFirstLong(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public long pollFirstLong(); + public long removeFirstLong(); /** * A method to get the last element in the set * @return last element in the set */ - public long lastLong(); + public long getLastLong(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public long pollLastLong(); + public long removeLastLong(); + + public default LongOrderedSet reversed() { return new ReversedLongOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/longs/sets/LongSet.java b/src/main/java/speiger/src/collections/longs/sets/LongSet.java index ed315a4..5db133e 100644 --- a/src/main/java/speiger/src/collections/longs/sets/LongSet.java +++ b/src/main/java/speiger/src/collections/longs/sets/LongSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.longs.collections.LongCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.collections.LongSplititerator; -import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.longs.utils.LongSplititerators; +import speiger.src.collections.longs.utils.LongSets; /** diff --git a/src/main/java/speiger/src/collections/longs/utils/LongCollections.java b/src/main/java/speiger/src/collections/longs/utils/LongCollections.java index 7629515..f082a75 100644 --- a/src/main/java/speiger/src/collections/longs/utils/LongCollections.java +++ b/src/main/java/speiger/src/collections/longs/utils/LongCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.longs.collections.AbstractLongCollection; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -50,6 +51,34 @@ public class LongCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static LongOrderedCollection unmodifiable(LongOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static LongOrderedCollection synchronize(LongOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static LongOrderedCollection synchronize(LongOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -583,6 +612,37 @@ public class LongCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements LongOrderedCollection { + LongOrderedCollection c; + + SynchronizedOrderedCollection(LongOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(LongOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public LongOrderedCollection reversed() { return LongCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(long e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(long e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public long getFirstLong() { synchronized(mutex) { return this.c.getFirstLong(); } } + @Override + public long removeFirstLong() { synchronized(mutex) { return this.c.removeFirstLong(); } } + @Override + public long getLastLong() { synchronized(mutex) { return this.c.getLastLong(); } } + @Override + public long removeLastLong() { synchronized(mutex) { return this.c.removeLastLong(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -704,6 +764,33 @@ public class LongCollections public int count(LongPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements LongOrderedCollection { + LongOrderedCollection c; + + UnmodifiableOrderedCollection(LongOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public LongOrderedCollection reversed() { return LongCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return c.getFirstLong(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return c.getLastLong(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/longs/utils/LongIterators.java b/src/main/java/speiger/src/collections/longs/utils/LongIterators.java index 8254a45..b4ecc4b 100644 --- a/src/main/java/speiger/src/collections/longs/utils/LongIterators.java +++ b/src/main/java/speiger/src/collections/longs/utils/LongIterators.java @@ -34,7 +34,7 @@ public class LongIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static LongListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class LongIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(long... a) { + public static LongIterator wrap(long... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class LongIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(long[] a, int start, int end) { + public static LongIterator wrap(long[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/longs/utils/LongLists.java b/src/main/java/speiger/src/collections/longs/utils/LongLists.java index 7602481..21f0555 100644 --- a/src/main/java/speiger/src/collections/longs/utils/LongLists.java +++ b/src/main/java/speiger/src/collections/longs/utils/LongLists.java @@ -30,7 +30,7 @@ public class LongLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static LongList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/longs/utils/LongSets.java b/src/main/java/speiger/src/collections/longs/utils/LongSets.java index da46c14..ceba2ee 100644 --- a/src/main/java/speiger/src/collections/longs/utils/LongSets.java +++ b/src/main/java/speiger/src/collections/longs/utils/LongSets.java @@ -312,17 +312,19 @@ public class LongSets @Override public LongBidirectionalIterator iterator() { return LongIterators.unmodifiable(s.iterator()); } @Override + public LongBidirectionalIterator reverseIterator() { return LongIterators.unmodifiable(s.reverseIterator()); } + @Override public LongBidirectionalIterator iterator(long fromElement) { return LongIterators.unmodifiable(s.iterator(fromElement)); } @Override public LongOrderedSet copy() { return s.copy(); } @Override - public long firstLong() { return s.firstLong(); } + public long getFirstLong() { return s.getFirstLong(); } @Override - public long pollFirstLong() { throw new UnsupportedOperationException(); } + public long removeFirstLong() { throw new UnsupportedOperationException(); } @Override - public long lastLong() { return s.lastLong(); } + public long getLastLong() { return s.getLastLong(); } @Override - public long pollLastLong() { throw new UnsupportedOperationException(); } + public long removeLastLong() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements LongSortedSet @@ -583,17 +585,19 @@ public class LongSets @Override public LongBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public LongBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public LongBidirectionalIterator iterator(long fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public LongOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public long firstLong() { synchronized(mutex) { return s.firstLong(); } } + public long getFirstLong() { synchronized(mutex) { return s.getFirstLong(); } } @Override - public long pollFirstLong() { synchronized(mutex) { return s.pollFirstLong(); } } + public long removeFirstLong() { synchronized(mutex) { return s.removeFirstLong(); } } @Override - public long lastLong() { synchronized(mutex) { return s.lastLong(); } } + public long getLastLong() { synchronized(mutex) { return s.getLastLong(); } } @Override - public long pollLastLong() { synchronized(mutex) { return s.pollLastLong(); } } + public long removeLastLong() { synchronized(mutex) { return s.removeLastLong(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2BooleanMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2BooleanMaps.java index 37d3641..c1f7220 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Long2BooleanMaps @Override public boolean putAndMoveToLast(long key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(long key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(long key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Long2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Long2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2BooleanOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet long2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Long2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2BooleanMap.Entry first() { return set.first(); } + public Long2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2BooleanMap.Entry last() { return set.last(); } + public Long2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Long2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Long2BooleanMaps @Override public boolean putAndMoveToLast(long key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(long key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(long key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Long2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Long2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet long2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ByteMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ByteMaps.java index 23d163a..f970a15 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ByteMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Long2ByteMaps @Override public byte putAndMoveToLast(long key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(long key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(long key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Long2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2ByteOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet long2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Long2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2ByteMap.Entry first() { return set.first(); } + public Long2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ByteMap.Entry last() { return set.last(); } + public Long2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Long2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2ByteMaps @Override public byte putAndMoveToLast(long key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(long key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(long key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Long2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet long2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2CharMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2CharMaps.java index 145d798..f129662 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2CharMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Long2CharMaps @Override public char putAndMoveToLast(long key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(long key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(long key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Long2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2CharOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet long2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2CharEntrySet()); @@ -617,15 +634,17 @@ public class Long2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2CharMap.Entry first() { return set.first(); } + public Long2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2CharMap.Entry last() { return set.last(); } + public Long2CharMap.Entry getLast() { return set.getLast(); } @Override - public Long2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2CharMaps @Override public char putAndMoveToLast(long key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(long key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(long key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Long2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet long2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2DoubleMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2DoubleMaps.java index 45c1ab9..f2d69a9 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Long2DoubleMaps @Override public double putAndMoveToLast(long key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(long key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(long key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Long2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2DoubleOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet long2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Long2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2DoubleMap.Entry first() { return set.first(); } + public Long2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2DoubleMap.Entry last() { return set.last(); } + public Long2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Long2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2DoubleMaps @Override public double putAndMoveToLast(long key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(long key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(long key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Long2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet long2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2FloatMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2FloatMaps.java index 9f28f22..b9f782f 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2FloatMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Long2FloatMaps @Override public float putAndMoveToLast(long key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(long key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(long key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Long2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2FloatOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet long2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Long2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2FloatMap.Entry first() { return set.first(); } + public Long2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2FloatMap.Entry last() { return set.last(); } + public Long2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Long2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2FloatMaps @Override public float putAndMoveToLast(long key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(long key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(long key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Long2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet long2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2IntMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2IntMaps.java index 3214c6a..6834eea 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2IntMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Long2IntMaps @Override public int putAndMoveToLast(long key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(long key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(long key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Long2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2IntOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet long2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2IntEntrySet()); @@ -617,15 +634,17 @@ public class Long2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2IntMap.Entry first() { return set.first(); } + public Long2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2IntMap.Entry last() { return set.last(); } + public Long2IntMap.Entry getLast() { return set.getLast(); } @Override - public Long2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2IntMaps @Override public int putAndMoveToLast(long key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(long key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(long key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Long2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet long2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2LongMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2LongMaps.java index 9473182..ed12013 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2LongMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -438,6 +439,10 @@ public class Long2LongMaps @Override public long putAndMoveToLast(long key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(long key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(long key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Long2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Long2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2LongOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet long2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2LongEntrySet()); @@ -616,15 +633,17 @@ public class Long2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2LongMap.Entry first() { return set.first(); } + public Long2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2LongMap.Entry last() { return set.last(); } + public Long2LongMap.Entry getLast() { return set.getLast(); } @Override - public Long2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Long2LongMaps @Override public long putAndMoveToLast(long key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(long key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(long key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Long2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Long2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet long2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ObjectMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ObjectMaps.java index 7e8ed8c..0d1c2ba 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Long2ObjectMaps @Override public V putAndMoveToLast(long key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(long key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(long key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Long2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2ObjectOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> long2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.long2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Long2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Long2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2ObjectMap.Entry first() { return set.first(); } + public Long2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ObjectMap.Entry last() { return set.last(); } + public Long2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Long2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Long2ObjectMaps @Override public V putAndMoveToLast(long key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(long key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(long key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Long2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Long2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> long2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ShortMaps.java b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ShortMaps.java index 67aa431..2b60591 100644 --- a/src/main/java/speiger/src/collections/longs/utils/maps/Long2ShortMaps.java +++ b/src/main/java/speiger/src/collections/longs/utils/maps/Long2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.longs.sets.LongOrderedSet; import speiger.src.collections.longs.sets.LongSet; import speiger.src.collections.longs.utils.LongSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -439,6 +440,10 @@ public class Long2ShortMaps @Override public short putAndMoveToLast(long key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(long key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(long key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(long key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(long key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Long2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Long2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Long2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Long2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Long2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Long2ShortOrderedMap copy() { return map.copy(); } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.unmodifiable(map.keySet()); return (LongOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet long2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.long2ShortEntrySet()); @@ -617,15 +634,17 @@ public class Long2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Long2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Long2ShortMap.Entry first() { return set.first(); } + public Long2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Long2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Long2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Long2ShortMap.Entry last() { return set.last(); } + public Long2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Long2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Long2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Long2ShortMaps @Override public short putAndMoveToLast(long key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(long key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(long key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(long key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(long key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Long2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Long2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Long2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Long2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Long2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Long2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public LongOrderedSet keySet() { if(keys == null) keys = LongSets.synchronize(map.keySet(), mutex); return (LongOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet long2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.long2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/collections/AbstractObjectCollection.java b/src/main/java/speiger/src/collections/objects/collections/AbstractObjectCollection.java index 100ac77..b2735a9 100644 --- a/src/main/java/speiger/src/collections/objects/collections/AbstractObjectCollection.java +++ b/src/main/java/speiger/src/collections/objects/collections/AbstractObjectCollection.java @@ -1,10 +1,12 @@ package speiger.src.collections.objects.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; import java.util.function.Consumer; +import speiger.src.collections.objects.lists.ObjectListIterator; /** * Abstract Type Specific Collection that reduces boxing/unboxing @@ -163,4 +165,67 @@ public abstract class AbstractObjectCollection extends AbstractCollection return modified; } + public static class ReverseObjectOrderedCollection extends AbstractObjectCollection implements ObjectOrderedCollection { + ObjectOrderedCollection collection; + Supplier> reverseIterator; + + public ReverseObjectOrderedCollection(ObjectOrderedCollection collection, Supplier> reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(T o) { return collection.add(o); } + @Override + public ObjectOrderedCollection reversed() { return collection; } + @Override + public void addFirst(T e) { collection.addLast(e); } + @Override + public void addLast(T e) { collection.addFirst(e); } + @Override + public boolean contains(Object e) { return collection.contains(e); } + @Override + public boolean remove(Object e) { return collection.remove(e); } + @Override + public void clear() { collection.clear(); } + @Override + public T getFirst() { return collection.getLast(); } + @Override + public T removeFirst() { return collection.removeLast(); } + @Override + public T getLast() { return collection.getFirst(); } + @Override + public T removeLast() { return collection.removeFirst(); } + @Override + public ObjectIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements ObjectListIterator { + ObjectListIterator it; + + public ReverseBiIterator(ObjectListIterator it) { + this.it = it; + } + + @Override + public T next() { return it.previous(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public T 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(T e) { it.set(e); } + @Override + public void add(T e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/objects/collections/ObjectOrderedCollection.java b/src/main/java/speiger/src/collections/objects/collections/ObjectOrderedCollection.java new file mode 100644 index 0000000..076b0df --- /dev/null +++ b/src/main/java/speiger/src/collections/objects/collections/ObjectOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.objects.collections; + +public interface ObjectOrderedCollection extends ObjectCollection { + + ObjectOrderedCollection 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(T 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(T e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public T getFirst(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public T removeFirst(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public T getLast(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public T removeLast(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/objects/lists/AbstractObjectList.java b/src/main/java/speiger/src/collections/objects/lists/AbstractObjectList.java index 3f56c12..071a0a2 100644 --- a/src/main/java/speiger/src/collections/objects/lists/AbstractObjectList.java +++ b/src/main/java/speiger/src/collections/objects/lists/AbstractObjectList.java @@ -426,7 +426,6 @@ public abstract class AbstractObjectList extends AbstractObjectCollection public int size() { return size; } - @Override public ObjectSplititerator spliterator() { return ObjectSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/objects/lists/CopyOnWriteObjectArrayList.java b/src/main/java/speiger/src/collections/objects/lists/CopyOnWriteObjectArrayList.java index 47683c1..02fc025 100644 --- a/src/main/java/speiger/src/collections/objects/lists/CopyOnWriteObjectArrayList.java +++ b/src/main/java/speiger/src/collections/objects/lists/CopyOnWriteObjectArrayList.java @@ -442,7 +442,6 @@ public class CopyOnWriteObjectArrayList extends AbstractObjectList impleme * @return if the element was found. */ @Override - @Deprecated public boolean contains(Object o) { return indexOf(o) != -1; } @@ -453,7 +452,6 @@ public class CopyOnWriteObjectArrayList extends AbstractObjectList impleme * @return the index of the element if found. (if not found then -1) */ @Override - @Deprecated public int indexOf(Object o) { T[] data = this.data; if(o == null) { @@ -473,7 +471,6 @@ public class CopyOnWriteObjectArrayList extends AbstractObjectList impleme * @return the last index of the element if found. (if not found then -1) */ @Override - @Deprecated public int lastIndexOf(Object o) { T[] data = this.data; if(o == null) { diff --git a/src/main/java/speiger/src/collections/objects/lists/ObjectLinkedList.java b/src/main/java/speiger/src/collections/objects/lists/ObjectLinkedList.java index eaf7b60..696c47c 100644 --- a/src/main/java/speiger/src/collections/objects/lists/ObjectLinkedList.java +++ b/src/main/java/speiger/src/collections/objects/lists/ObjectLinkedList.java @@ -329,7 +329,7 @@ public class ObjectLinkedList extends AbstractObjectList implements Object if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator diff --git a/src/main/java/speiger/src/collections/objects/lists/ObjectList.java b/src/main/java/speiger/src/collections/objects/lists/ObjectList.java index 17fb787..8ff8e1f 100644 --- a/src/main/java/speiger/src/collections/objects/lists/ObjectList.java +++ b/src/main/java/speiger/src/collections/objects/lists/ObjectList.java @@ -7,6 +7,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectSplititerator; import speiger.src.collections.ints.functions.consumer.IntObjectConsumer; import speiger.src.collections.objects.utils.ObjectArrays; @@ -18,7 +19,7 @@ import speiger.src.collections.objects.utils.ObjectSplititerators; * A Type Specific List interface that reduces boxing/unboxing and adds a couple extra quality of life features * @param the keyType of elements maintained by this Collection */ -public interface ObjectList extends ObjectCollection, List +public interface ObjectList extends ObjectOrderedCollection, List { /** * A Helper function that will only add elements if it is not present. @@ -64,6 +65,24 @@ public interface ObjectList extends ObjectCollection, List */ public boolean addAll(int index, ObjectList 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(T 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(T e) { + add(e); + } + /** * 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. diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2BooleanMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2BooleanMap.java index 4381c53..e403001 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2BooleanMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2BooleanMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.objects.functions.function.ObjectBooleanUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2BooleanMap; +import speiger.src.collections.objects.maps.interfaces.Object2BooleanOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2BooleanMaps; @@ -84,7 +87,7 @@ public abstract class AbstractObject2BooleanMap extends AbstractMap extends AbstractMap extends AbstractObject2BooleanMap implements Object2BooleanOrderedMap { + Object2BooleanOrderedMap map; + + public ReversedObject2BooleanOrderedMap(Object2BooleanOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2BooleanMap setDefaultReturnValue(boolean v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public boolean getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2BooleanOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public boolean put(T key, boolean value) { return map.put(key, value); } + @Override + public boolean putIfAbsent(T key, boolean value) { return map.putIfAbsent(key, value); } + @Override + public boolean rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, boolean value) { return map.remove(key, value); } + @Override + public boolean remOrDefault(T key, boolean defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(boolean value) { return map.containsValue(value); } + @Override + public boolean replace(T key, boolean oldValue, boolean newValue) { return map.replace(key, oldValue, newValue); } + @Override + public boolean replace(T key, boolean value) { return map.replace(key, value); } + @Override + public void replaceBooleans(Object2BooleanMap m) { map.replaceBooleans(m); } + @Override + public void replaceBooleans(ObjectBooleanUnaryOperator mappingFunction) { map.replaceBooleans(mappingFunction); } + @Override + public boolean computeBoolean(T key, ObjectBooleanUnaryOperator mappingFunction) { return map.computeBoolean(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsent(T key, Predicate mappingFunction) { return map.computeBooleanIfAbsent(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsent(T key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsent(key, valueProvider); } + @Override + public boolean computeBooleanIfPresent(T key, ObjectBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresent(key, mappingFunction); } + @Override + public boolean computeBooleanNonDefault(T key, ObjectBooleanUnaryOperator mappingFunction) { return map.computeBooleanNonDefault(key, mappingFunction); } + @Override + public boolean computeBooleanIfAbsentNonDefault(T key, Predicate mappingFunction) { return map.computeBooleanIfAbsentNonDefault(key, mappingFunction); } + @Override + public boolean supplyBooleanIfAbsentNonDefault(T key, BooleanSupplier valueProvider) { return map.supplyBooleanIfAbsentNonDefault(key, valueProvider); } + @Override + public boolean computeBooleanIfPresentNonDefault(T key, ObjectBooleanUnaryOperator mappingFunction) { return map.computeBooleanIfPresentNonDefault(key, mappingFunction); } + @Override + public boolean mergeBoolean(T key, boolean value, BooleanBooleanUnaryOperator mappingFunction) { return map.mergeBoolean(key, value, mappingFunction); } + @Override + public boolean getOrDefault(T key, boolean defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public boolean getBoolean(T key) { return map.getBoolean(key); } + @Override + public boolean putAndMoveToFirst(T key, boolean value) { return map.putAndMoveToLast(key, value); } + @Override + public boolean putAndMoveToLast(T key, boolean value) { return map.putAndMoveToFirst(key, value); } + @Override + public boolean putFirst(T key, boolean value) { return map.putLast(key, value); } + @Override + public boolean putLast(T key, boolean value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public boolean getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public boolean getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public boolean firstBooleanValue() { return map.lastBooleanValue(); } + @Override + public boolean lastBooleanValue() { return map.firstBooleanValue(); } + @Override + public Object2BooleanMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2BooleanMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2BooleanMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2BooleanMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2BooleanEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ByteMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ByteMap.java index 71996ce..11b3448 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ByteMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ByteMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.objects.functions.function.ToByteFunction; import speiger.src.collections.objects.functions.function.ObjectByteUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2ByteMap; +import speiger.src.collections.objects.maps.interfaces.Object2ByteOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2ByteMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2ByteMap extends AbstractMap implements Object2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2ByteMap extends AbstractMap imp public void putAll(T[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap imp return hash; } + public static class ReversedObject2ByteOrderedMap extends AbstractObject2ByteMap implements Object2ByteOrderedMap { + Object2ByteOrderedMap map; + + public ReversedObject2ByteOrderedMap(Object2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(T key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(T key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(T key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(T key, byte value) { return map.subFrom(key, value); } + @Override + public byte rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, byte value) { return map.remove(key, value); } + @Override + public byte remOrDefault(T key, byte defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(T key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(T key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Object2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(ObjectByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(T key, ObjectByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(T key, ToByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(T key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(T key, ObjectByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(T key, ObjectByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(T key, ToByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(T key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(T key, ObjectByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(T key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(T key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte getByte(T key) { return map.getByte(key); } + @Override + public byte putAndMoveToFirst(T key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(T key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(T key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(T key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Object2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2ByteEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2CharMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2CharMap.java index a323c74..2b4dc9d 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2CharMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2CharMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.objects.functions.function.ToCharFunction; import speiger.src.collections.objects.functions.function.ObjectCharUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2CharMap; +import speiger.src.collections.objects.maps.interfaces.Object2CharOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2CharMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2CharMap extends AbstractMap implements Object2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2CharMap extends AbstractMap extends AbstractMap extends AbstractObject2CharMap implements Object2CharOrderedMap { + Object2CharOrderedMap map; + + public ReversedObject2CharOrderedMap(Object2CharOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2CharMap setDefaultReturnValue(char v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public char getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2CharOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public char put(T key, char value) { return map.put(key, value); } + @Override + public char putIfAbsent(T key, char value) { return map.putIfAbsent(key, value); } + @Override + public char addTo(T key, char value) { return map.addTo(key, value); } + @Override + public char subFrom(T key, char value) { return map.subFrom(key, value); } + @Override + public char rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, char value) { return map.remove(key, value); } + @Override + public char remOrDefault(T key, char defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(char value) { return map.containsValue(value); } + @Override + public boolean replace(T key, char oldValue, char newValue) { return map.replace(key, oldValue, newValue); } + @Override + public char replace(T key, char value) { return map.replace(key, value); } + @Override + public void replaceChars(Object2CharMap m) { map.replaceChars(m); } + @Override + public void replaceChars(ObjectCharUnaryOperator mappingFunction) { map.replaceChars(mappingFunction); } + @Override + public char computeChar(T key, ObjectCharUnaryOperator mappingFunction) { return map.computeChar(key, mappingFunction); } + @Override + public char computeCharIfAbsent(T key, ToCharFunction mappingFunction) { return map.computeCharIfAbsent(key, mappingFunction); } + @Override + public char supplyCharIfAbsent(T key, CharSupplier valueProvider) { return map.supplyCharIfAbsent(key, valueProvider); } + @Override + public char computeCharIfPresent(T key, ObjectCharUnaryOperator mappingFunction) { return map.computeCharIfPresent(key, mappingFunction); } + @Override + public char computeCharNonDefault(T key, ObjectCharUnaryOperator mappingFunction) { return map.computeCharNonDefault(key, mappingFunction); } + @Override + public char computeCharIfAbsentNonDefault(T key, ToCharFunction mappingFunction) { return map.computeCharIfAbsentNonDefault(key, mappingFunction); } + @Override + public char supplyCharIfAbsentNonDefault(T key, CharSupplier valueProvider) { return map.supplyCharIfAbsentNonDefault(key, valueProvider); } + @Override + public char computeCharIfPresentNonDefault(T key, ObjectCharUnaryOperator mappingFunction) { return map.computeCharIfPresentNonDefault(key, mappingFunction); } + @Override + public char mergeChar(T key, char value, CharCharUnaryOperator mappingFunction) { return map.mergeChar(key, value, mappingFunction); } + @Override + public char getOrDefault(T key, char defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public char getChar(T key) { return map.getChar(key); } + @Override + public char putAndMoveToFirst(T key, char value) { return map.putAndMoveToLast(key, value); } + @Override + public char putAndMoveToLast(T key, char value) { return map.putAndMoveToFirst(key, value); } + @Override + public char putFirst(T key, char value) { return map.putLast(key, value); } + @Override + public char putLast(T key, char value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public char getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public char getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public char firstCharValue() { return map.lastCharValue(); } + @Override + public char lastCharValue() { return map.firstCharValue(); } + @Override + public Object2CharMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2CharMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2CharMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2CharMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2CharEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2DoubleMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2DoubleMap.java index 4c26865..1bacc04 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2DoubleMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2DoubleMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.objects.functions.function.ToDoubleFunction; import speiger.src.collections.objects.functions.function.ObjectDoubleUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2DoubleMap; +import speiger.src.collections.objects.maps.interfaces.Object2DoubleOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2DoubleMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2DoubleMap extends AbstractMap implements Object2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2DoubleMap extends AbstractMap public void putAll(T[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap return hash; } + public static class ReversedObject2DoubleOrderedMap extends AbstractObject2DoubleMap implements Object2DoubleOrderedMap { + Object2DoubleOrderedMap map; + + public ReversedObject2DoubleOrderedMap(Object2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(T key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(T key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(T key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(T key, double value) { return map.subFrom(key, value); } + @Override + public double rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, double value) { return map.remove(key, value); } + @Override + public double remOrDefault(T key, double defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(T key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(T key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Object2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(ObjectDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(T key, ObjectDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(T key, ToDoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(T key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(T key, ObjectDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(T key, ObjectDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(T key, ToDoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(T key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(T key, ObjectDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(T key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(T key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double getDouble(T key) { return map.getDouble(key); } + @Override + public double putAndMoveToFirst(T key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(T key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(T key, double value) { return map.putLast(key, value); } + @Override + public double putLast(T key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Object2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2DoubleEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2FloatMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2FloatMap.java index ed86fe7..ce3597d 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2FloatMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2FloatMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.objects.functions.function.ToFloatFunction; import speiger.src.collections.objects.functions.function.ObjectFloatUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2FloatMap; +import speiger.src.collections.objects.maps.interfaces.Object2FloatOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2FloatMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2FloatMap extends AbstractMap implements Object2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2FloatMap extends AbstractMap i public void putAll(T[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedObject2FloatOrderedMap extends AbstractObject2FloatMap implements Object2FloatOrderedMap { + Object2FloatOrderedMap map; + + public ReversedObject2FloatOrderedMap(Object2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(T key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(T key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(T key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(T key, float value) { return map.subFrom(key, value); } + @Override + public float rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, float value) { return map.remove(key, value); } + @Override + public float remOrDefault(T key, float defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(T key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(T key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Object2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(ObjectFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(T key, ObjectFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(T key, ToFloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(T key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(T key, ObjectFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(T key, ObjectFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(T key, ToFloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(T key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(T key, ObjectFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(T key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(T key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float getFloat(T key) { return map.getFloat(key); } + @Override + public float putAndMoveToFirst(T key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(T key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(T key, float value) { return map.putLast(key, value); } + @Override + public float putLast(T key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Object2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2FloatEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2IntMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2IntMap.java index 8da0824..d89c9b8 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2IntMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2IntMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.objects.functions.function.ToIntFunction; import speiger.src.collections.objects.functions.function.ObjectIntUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2IntMap; +import speiger.src.collections.objects.maps.interfaces.Object2IntOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2IntMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2IntMap extends AbstractMap implements Object2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2IntMap extends AbstractMap i public void putAll(T[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedObject2IntOrderedMap extends AbstractObject2IntMap implements Object2IntOrderedMap { + Object2IntOrderedMap map; + + public ReversedObject2IntOrderedMap(Object2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(T key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(T key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(T key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(T key, int value) { return map.subFrom(key, value); } + @Override + public int rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, int value) { return map.remove(key, value); } + @Override + public int remOrDefault(T key, int defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(T key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(T key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Object2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(ObjectIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(T key, ObjectIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(T key, ToIntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(T key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(T key, ObjectIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(T key, ObjectIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(T key, ToIntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(T key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(T key, ObjectIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(T key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(T key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int getInt(T key) { return map.getInt(key); } + @Override + public int putAndMoveToFirst(T key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(T key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(T key, int value) { return map.putLast(key, value); } + @Override + public int putLast(T key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Object2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2IntEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2LongMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2LongMap.java index 02a034d..2c3888c 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2LongMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2LongMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.objects.functions.function.ToLongFunction; import speiger.src.collections.objects.functions.function.ObjectLongUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2LongMap; +import speiger.src.collections.objects.maps.interfaces.Object2LongOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2LongMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2LongMap extends AbstractMap implements Object2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2LongMap extends AbstractMap imp public void putAll(T[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap imp return hash; } + public static class ReversedObject2LongOrderedMap extends AbstractObject2LongMap implements Object2LongOrderedMap { + Object2LongOrderedMap map; + + public ReversedObject2LongOrderedMap(Object2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(T key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(T key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(T key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(T key, long value) { return map.subFrom(key, value); } + @Override + public long rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, long value) { return map.remove(key, value); } + @Override + public long remOrDefault(T key, long defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(T key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(T key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Object2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(ObjectLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(T key, ObjectLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(T key, ToLongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(T key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(T key, ObjectLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(T key, ObjectLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(T key, ToLongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(T key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(T key, ObjectLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(T key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(T key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long getLong(T key) { return map.getLong(key); } + @Override + public long putAndMoveToFirst(T key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(T key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(T key, long value) { return map.putLast(key, value); } + @Override + public long putLast(T key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Object2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2LongEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ObjectMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ObjectMap.java index aa866e4..7ecef43 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ObjectMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ObjectMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.UnaryOperator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2ObjectMap; +import speiger.src.collections.objects.maps.interfaces.Object2ObjectOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2ObjectMaps; @@ -351,6 +354,100 @@ public abstract class AbstractObject2ObjectMap extends AbstractMap i return hash; } + public static class ReversedObject2ObjectOrderedMap extends AbstractObject2ObjectMap implements Object2ObjectOrderedMap { + Object2ObjectOrderedMap map; + + public ReversedObject2ObjectOrderedMap(Object2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(T key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(T key, V value) { return map.putIfAbsent(key, value); } + @Override + public V rem(T key) { return map.rem(key); } + @Override + public V remOrDefault(T key, V defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(T key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(T key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Object2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(ObjectObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(T key, ObjectObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(T key, UnaryOperator mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(T key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(T key, ObjectObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(T key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getObject(T key) { return map.getObject(key); } + @Override + public V putAndMoveToFirst(T key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(T key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(T key, V value) { return map.putLast(key, value); } + @Override + public V putLast(T key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Object2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2ObjectEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ShortMap.java b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ShortMap.java index 852c7c1..5b56943 100644 --- a/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ShortMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/abstracts/AbstractObject2ShortMap.java @@ -9,6 +9,9 @@ import speiger.src.collections.objects.functions.consumer.ObjectShortConsumer; import speiger.src.collections.objects.functions.function.ToShortFunction; import speiger.src.collections.objects.functions.function.ObjectShortUnaryOperator; import speiger.src.collections.objects.maps.interfaces.Object2ShortMap; +import speiger.src.collections.objects.maps.interfaces.Object2ShortOrderedMap; +import speiger.src.collections.objects.sets.ObjectOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectSet; import speiger.src.collections.objects.utils.maps.Object2ShortMaps; @@ -26,7 +29,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractObject2ShortMap extends AbstractMap implements Object2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -90,7 +93,7 @@ public abstract class AbstractObject2ShortMap extends AbstractMap i public void putAll(T[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedObject2ShortOrderedMap extends AbstractObject2ShortMap implements Object2ShortOrderedMap { + Object2ShortOrderedMap map; + + public ReversedObject2ShortOrderedMap(Object2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractObject2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Object2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(T key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(T key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(T key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(T key, short value) { return map.subFrom(key, value); } + @Override + public short rem(T key) { return map.rem(key); } + @Override + public boolean remove(T key, short value) { return map.remove(key, value); } + @Override + public short remOrDefault(T key, short defaultValue) { return map.remOrDefault(key, defaultValue); } + @Override + public boolean containsKey(Object key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(T key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(T key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Object2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(ObjectShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(T key, ObjectShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(T key, ToShortFunction mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(T key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(T key, ObjectShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(T key, ObjectShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(T key, ToShortFunction mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(T key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(T key, ObjectShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(T key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(T key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short getShort(T key) { return map.getShort(key); } + @Override + public short putAndMoveToFirst(T key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(T key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(T key, short value) { return map.putLast(key, value); } + @Override + public short putLast(T key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(T key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(T key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(T key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(T key) { return map.getAndMoveToFirst(key); } + @Override + public T firstKey() { return map.lastKey(); } + @Override + public T pollFirstKey() { return map.pollLastKey(); } + @Override + public T lastKey() { return map.firstKey(); } + @Override + public T pollLastKey() { return map.pollFirstKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Object2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Object2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Object2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Object2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> object2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.object2ShortEntrySet()); } + @Override + public ObjectOrderedSet keySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Object2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2BooleanLinkedOpenCustomHashMap.java index 2232657..e953cab 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2BooleanLinkedOpenCustomHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -249,6 +249,54 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen return getDefaultReturnValue(); } + @Override + public boolean putFirst(T key, boolean value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 boolean putLast(T key, boolean value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen return values[lastIndex]; } + @Override + public Object2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } @Override - public Object2BooleanMap.Entry first() { + public Object2BooleanMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstBooleanValue()); } @Override - public Object2BooleanMap.Entry last() { + public Object2BooleanMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastBooleanValue()); } @Override - public Object2BooleanMap.Entry pollFirst() { + public Object2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstBooleanValue()); pollFirstKey(); return entry; } @Override - public Object2BooleanMap.Entry pollLast() { + public Object2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastBooleanValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Object2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1275,16 +1390,20 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2BooleanLinkedOpenCustomHashMap extends Object2BooleanOpen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ByteLinkedOpenCustomHashMap.java index 5310377..2aefd20 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ByteLinkedOpenCustomHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -249,6 +249,54 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom return getDefaultReturnValue(); } + @Override + public byte putFirst(T key, byte value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 byte putLast(T key, byte value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom return values[lastIndex]; } + @Override + public Object2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } @Override - public Object2ByteMap.Entry first() { + public Object2ByteMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstByteValue()); } @Override - public Object2ByteMap.Entry last() { + public Object2ByteMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastByteValue()); } @Override - public Object2ByteMap.Entry pollFirst() { + public Object2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstByteValue()); pollFirstKey(); return entry; } @Override - public Object2ByteMap.Entry pollLast() { + public Object2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastByteValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Object2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1275,16 +1390,20 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2ByteLinkedOpenCustomHashMap extends Object2ByteOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2CharLinkedOpenCustomHashMap.java index 7906330..6ee2470 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2CharLinkedOpenCustomHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -249,6 +249,54 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom return getDefaultReturnValue(); } + @Override + public char putFirst(T key, char value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 char putLast(T key, char value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom return values[lastIndex]; } + @Override + public Object2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } @Override - public Object2CharMap.Entry first() { + public Object2CharMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstCharValue()); } @Override - public Object2CharMap.Entry last() { + public Object2CharMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastCharValue()); } @Override - public Object2CharMap.Entry pollFirst() { + public Object2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstCharValue()); pollFirstKey(); return entry; } @Override - public Object2CharMap.Entry pollLast() { + public Object2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastCharValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Object2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1275,16 +1390,20 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2CharLinkedOpenCustomHashMap extends Object2CharOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2DoubleLinkedOpenCustomHashMap.java index c71204a..c64ac4e 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2DoubleLinkedOpenCustomHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -249,6 +249,54 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu return getDefaultReturnValue(); } + @Override + public double putFirst(T key, double value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 double putLast(T key, double value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu return values[lastIndex]; } + @Override + public Object2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } @Override - public Object2DoubleMap.Entry first() { + public Object2DoubleMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstDoubleValue()); } @Override - public Object2DoubleMap.Entry last() { + public Object2DoubleMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastDoubleValue()); } @Override - public Object2DoubleMap.Entry pollFirst() { + public Object2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstDoubleValue()); pollFirstKey(); return entry; } @Override - public Object2DoubleMap.Entry pollLast() { + public Object2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastDoubleValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Object2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1275,16 +1390,20 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2DoubleLinkedOpenCustomHashMap extends Object2DoubleOpenCu public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2FloatLinkedOpenCustomHashMap.java index f6a8934..d14ac92 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2FloatLinkedOpenCustomHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -249,6 +249,54 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust return getDefaultReturnValue(); } + @Override + public float putFirst(T key, float value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 float putLast(T key, float value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust return values[lastIndex]; } + @Override + public Object2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } @Override - public Object2FloatMap.Entry first() { + public Object2FloatMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstFloatValue()); } @Override - public Object2FloatMap.Entry last() { + public Object2FloatMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastFloatValue()); } @Override - public Object2FloatMap.Entry pollFirst() { + public Object2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstFloatValue()); pollFirstKey(); return entry; } @Override - public Object2FloatMap.Entry pollLast() { + public Object2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastFloatValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Object2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1275,16 +1390,20 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2FloatLinkedOpenCustomHashMap extends Object2FloatOpenCust public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2IntLinkedOpenCustomHashMap.java index effd18b..9c999ec 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2IntLinkedOpenCustomHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -249,6 +249,54 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa return getDefaultReturnValue(); } + @Override + public int putFirst(T key, int value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 int putLast(T key, int value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa return values[lastIndex]; } + @Override + public Object2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } @Override - public Object2IntMap.Entry first() { + public Object2IntMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstIntValue()); } @Override - public Object2IntMap.Entry last() { + public Object2IntMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastIntValue()); } @Override - public Object2IntMap.Entry pollFirst() { + public Object2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstIntValue()); pollFirstKey(); return entry; } @Override - public Object2IntMap.Entry pollLast() { + public Object2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastIntValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Object2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1275,16 +1390,20 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2IntLinkedOpenCustomHashMap extends Object2IntOpenCustomHa public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2LongLinkedOpenCustomHashMap.java index 8769e1c..7b3c4d2 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2LongLinkedOpenCustomHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -249,6 +249,54 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom return getDefaultReturnValue(); } + @Override + public long putFirst(T key, long value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 long putLast(T key, long value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom return values[lastIndex]; } + @Override + public Object2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } @Override - public Object2LongMap.Entry first() { + public Object2LongMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstLongValue()); } @Override - public Object2LongMap.Entry last() { + public Object2LongMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastLongValue()); } @Override - public Object2LongMap.Entry pollFirst() { + public Object2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstLongValue()); pollFirstKey(); return entry; } @Override - public Object2LongMap.Entry pollLast() { + public Object2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastLongValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Object2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1275,16 +1390,20 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2LongLinkedOpenCustomHashMap extends Object2LongOpenCustom public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ObjectLinkedOpenCustomHashMap.java index 8bd2222..41cb1c1 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ObjectLinkedOpenCustomHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.utils.HashUtil; @@ -215,6 +215,54 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe return getDefaultReturnValue(); } + @Override + public V putFirst(T key, V value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 V putLast(T key, V value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -350,6 +398,52 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe return values[lastIndex]; } + @Override + public Object2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -363,9 +457,9 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -550,24 +644,24 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } @Override - public Object2ObjectMap.Entry first() { + public Object2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstValue()); } @Override - public Object2ObjectMap.Entry last() { + public Object2ObjectMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastValue()); } @Override - public Object2ObjectMap.Entry pollFirst() { + public Object2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstValue()); pollFirstKey(); return entry; } @Override - public Object2ObjectMap.Entry pollLast() { + public Object2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastValue()); pollLastKey(); return entry; @@ -575,7 +669,12 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -585,7 +684,7 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -821,7 +920,12 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -843,22 +947,22 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -987,31 +1091,42 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Object2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Object2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Object2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastKey(); + return result; } @Override @@ -1142,7 +1257,7 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1169,7 +1284,7 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1221,7 +1336,7 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1242,16 +1357,20 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1279,11 +1398,11 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1343,20 +1462,30 @@ public class Object2ObjectLinkedOpenCustomHashMap extends Object2ObjectOpe public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ShortLinkedOpenCustomHashMap.java index c63ecb4..af60ea1 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/customHash/Object2ShortLinkedOpenCustomHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.utils.ObjectStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -249,6 +249,54 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust return getDefaultReturnValue(); } + @Override + public short putFirst(T key, short value) { + if(strategy.equals(key, null)) { + 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], null)) { + 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 short putLast(T key, short value) { + if(strategy.equals(key, null)) { + 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], null)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || strategy.equals(firstKey(), key)) return false; @@ -384,6 +432,52 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust return values[lastIndex]; } + @Override + public Object2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getKey(), null)) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } @Override - public Object2ShortMap.Entry first() { + public Object2ShortMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstShortValue()); } @Override - public Object2ShortMap.Entry last() { + public Object2ShortMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastShortValue()); } @Override - public Object2ShortMap.Entry pollFirst() { + public Object2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstShortValue()); pollFirstKey(); return entry; } @Override - public Object2ShortMap.Entry pollLast() { + public Object2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastShortValue()); pollLastKey(); return entry; @@ -609,7 +703,12 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -855,7 +954,12 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -877,22 +981,22 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1021,30 +1125,41 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Object2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Object2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Object2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Object2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastKey(); + return result; } @Override @@ -1175,7 +1290,7 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1202,7 +1317,7 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1232,7 +1347,7 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1254,7 +1369,7 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1275,16 +1390,20 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1312,11 +1431,11 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1376,20 +1495,30 @@ public class Object2ShortLinkedOpenCustomHashMap extends Object2ShortOpenCust public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2BooleanLinkedOpenHashMap.java index 8fd6b3f..9a08c5c 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2BooleanLinkedOpenHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2BooleanOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -226,6 +226,54 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa return getDefaultReturnValue(); } + @Override + public boolean putFirst(T key, boolean value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 boolean putLast(T key, boolean value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa return values[lastIndex]; } + @Override + public Object2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } @Override - public Object2BooleanMap.Entry first() { + public Object2BooleanMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstBooleanValue()); } @Override - public Object2BooleanMap.Entry last() { + public Object2BooleanMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastBooleanValue()); } @Override - public Object2BooleanMap.Entry pollFirst() { + public Object2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstBooleanValue()); pollFirstKey(); return entry; } @Override - public Object2BooleanMap.Entry pollLast() { + public Object2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastBooleanValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Object2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1271,13 +1386,16 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2BooleanLinkedOpenHashMap extends Object2BooleanOpenHashMa public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ByteLinkedOpenHashMap.java index a5ef9be..71b62ac 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ByteLinkedOpenHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ByteOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -226,6 +226,54 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i return getDefaultReturnValue(); } + @Override + public byte putFirst(T key, byte value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 byte putLast(T key, byte value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i return values[lastIndex]; } + @Override + public Object2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } @Override - public Object2ByteMap.Entry first() { + public Object2ByteMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstByteValue()); } @Override - public Object2ByteMap.Entry last() { + public Object2ByteMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastByteValue()); } @Override - public Object2ByteMap.Entry pollFirst() { + public Object2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstByteValue()); pollFirstKey(); return entry; } @Override - public Object2ByteMap.Entry pollLast() { + public Object2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastByteValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Object2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1271,13 +1386,16 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2ByteLinkedOpenHashMap extends Object2ByteOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2CharLinkedOpenHashMap.java index 2974c5d..086be49 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2CharLinkedOpenHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2CharOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -226,6 +226,54 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i return getDefaultReturnValue(); } + @Override + public char putFirst(T key, char value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 char putLast(T key, char value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i return values[lastIndex]; } + @Override + public Object2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } @Override - public Object2CharMap.Entry first() { + public Object2CharMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstCharValue()); } @Override - public Object2CharMap.Entry last() { + public Object2CharMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastCharValue()); } @Override - public Object2CharMap.Entry pollFirst() { + public Object2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstCharValue()); pollFirstKey(); return entry; } @Override - public Object2CharMap.Entry pollLast() { + public Object2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastCharValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2CharLinkedOpenHashMap.this.clear(); + public void clear() { Object2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1271,13 +1386,16 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2CharLinkedOpenHashMap extends Object2CharOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2DoubleLinkedOpenHashMap.java index 6eb3e95..fbc7e63 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2DoubleLinkedOpenHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2DoubleOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -226,6 +226,54 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< return getDefaultReturnValue(); } + @Override + public double putFirst(T key, double value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 double putLast(T key, double value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< return values[lastIndex]; } + @Override + public Object2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } @Override - public Object2DoubleMap.Entry first() { + public Object2DoubleMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstDoubleValue()); } @Override - public Object2DoubleMap.Entry last() { + public Object2DoubleMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastDoubleValue()); } @Override - public Object2DoubleMap.Entry pollFirst() { + public Object2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstDoubleValue()); pollFirstKey(); return entry; } @Override - public Object2DoubleMap.Entry pollLast() { + public Object2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastDoubleValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Object2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1271,13 +1386,16 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2DoubleLinkedOpenHashMap extends Object2DoubleOpenHashMap< public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2FloatLinkedOpenHashMap.java index abe4744..c64ffb6 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2FloatLinkedOpenHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2FloatOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -226,6 +226,54 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap return getDefaultReturnValue(); } + @Override + public float putFirst(T key, float value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 float putLast(T key, float value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap return values[lastIndex]; } + @Override + public Object2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } @Override - public Object2FloatMap.Entry first() { + public Object2FloatMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstFloatValue()); } @Override - public Object2FloatMap.Entry last() { + public Object2FloatMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastFloatValue()); } @Override - public Object2FloatMap.Entry pollFirst() { + public Object2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstFloatValue()); pollFirstKey(); return entry; } @Override - public Object2FloatMap.Entry pollLast() { + public Object2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastFloatValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Object2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1271,13 +1386,16 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2FloatLinkedOpenHashMap extends Object2FloatOpenHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2IntLinkedOpenHashMap.java index 99a3b28..bd53273 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2IntLinkedOpenHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2IntOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -226,6 +226,54 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp return getDefaultReturnValue(); } + @Override + public int putFirst(T key, int value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 int putLast(T key, int value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp return values[lastIndex]; } + @Override + public Object2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } @Override - public Object2IntMap.Entry first() { + public Object2IntMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstIntValue()); } @Override - public Object2IntMap.Entry last() { + public Object2IntMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastIntValue()); } @Override - public Object2IntMap.Entry pollFirst() { + public Object2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstIntValue()); pollFirstKey(); return entry; } @Override - public Object2IntMap.Entry pollLast() { + public Object2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastIntValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2IntLinkedOpenHashMap.this.clear(); + public void clear() { Object2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1271,13 +1386,16 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2IntLinkedOpenHashMap extends Object2IntOpenHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2LongLinkedOpenHashMap.java index 8617708..a220e20 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2LongLinkedOpenHashMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2LongOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -226,6 +226,54 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i return getDefaultReturnValue(); } + @Override + public long putFirst(T key, long value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 long putLast(T key, long value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i return values[lastIndex]; } + @Override + public Object2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } @Override - public Object2LongMap.Entry first() { + public Object2LongMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstLongValue()); } @Override - public Object2LongMap.Entry last() { + public Object2LongMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastLongValue()); } @Override - public Object2LongMap.Entry pollFirst() { + public Object2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstLongValue()); pollFirstKey(); return entry; } @Override - public Object2LongMap.Entry pollLast() { + public Object2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastLongValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2LongLinkedOpenHashMap.this.clear(); + public void clear() { Object2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1271,13 +1386,16 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2LongLinkedOpenHashMap extends Object2LongOpenHashMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ObjectLinkedOpenHashMap.java index 4712a16..cab9ae3 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ObjectLinkedOpenHashMap.java @@ -18,7 +18,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ObjectOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.utils.HashUtil; @@ -196,6 +196,54 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM return getDefaultReturnValue(); } + @Override + public V putFirst(T key, V value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 V putLast(T key, V value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -341,6 +389,52 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM return values[lastIndex]; } + @Override + public Object2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -354,9 +448,9 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -541,24 +635,24 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } @Override - public Object2ObjectMap.Entry first() { + public Object2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstValue()); } @Override - public Object2ObjectMap.Entry last() { + public Object2ObjectMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastValue()); } @Override - public Object2ObjectMap.Entry pollFirst() { + public Object2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstValue()); pollFirstKey(); return entry; } @Override - public Object2ObjectMap.Entry pollLast() { + public Object2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastValue()); pollLastKey(); return entry; @@ -566,7 +660,12 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -576,7 +675,7 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -810,7 +909,12 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -832,22 +936,22 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -976,33 +1080,44 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Object2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1132,7 +1247,7 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1159,7 +1274,7 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1189,7 +1304,7 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1211,7 +1326,7 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1231,13 +1346,16 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1268,11 +1386,11 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1332,20 +1450,30 @@ public class Object2ObjectLinkedOpenHashMap extends Object2ObjectOpenHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ShortLinkedOpenHashMap.java index e8ccc91..5512fd1 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/hash/Object2ShortLinkedOpenHashMap.java @@ -19,7 +19,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ShortOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortConsumer; @@ -226,6 +226,54 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap return getDefaultReturnValue(); } + @Override + public short putFirst(T key, short value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.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 short putLast(T key, short value) { + if(key == null) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Objects.hashCode(key)) & mask; + while(key == null) { + if(Objects.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { if(isEmpty() || Objects.equals(firstKey(), key)) return false; @@ -382,6 +430,52 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap return values[lastIndex]; } + @Override + public Object2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Object2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getKey() == null) { + containsNull = false; + keys[nullIndex] = null; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> object2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -395,9 +489,9 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -582,24 +676,24 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } @Override - public Object2ShortMap.Entry first() { + public Object2ShortMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstShortValue()); } @Override - public Object2ShortMap.Entry last() { + public Object2ShortMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastShortValue()); } @Override - public Object2ShortMap.Entry pollFirst() { + public Object2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstShortValue()); pollFirstKey(); return entry; } @Override - public Object2ShortMap.Entry pollLast() { + public Object2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastShortValue()); pollLastKey(); return entry; @@ -607,7 +701,12 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -617,7 +716,7 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -851,7 +950,12 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -873,22 +977,22 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -1017,32 +1121,43 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Object2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Object2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Object2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1172,7 +1287,7 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1199,7 +1314,7 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1229,7 +1344,7 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1251,7 +1366,7 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1271,13 +1386,16 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1308,11 +1426,11 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1372,20 +1490,30 @@ public class Object2ShortLinkedOpenHashMap extends Object2ShortOpenHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2BooleanOpenHashMap.java index ccbf6c3..2fb2cb9 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2BooleanOpenHashMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -63,7 +63,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -248,6 +248,10 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea @Override public boolean putAndMoveToLast(T key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(T key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(T key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -344,7 +348,24 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2BooleanEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -494,24 +515,29 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea public boolean moveToLast(Object2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2BooleanMap.Entry first() { + public Object2BooleanMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstBooleanValue()); } @Override - public Object2BooleanMap.Entry last() { + public Object2BooleanMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastBooleanValue()); } @Override - public Object2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -521,7 +547,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -737,7 +763,12 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -757,20 +788,20 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -897,30 +928,35 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1049,7 +1085,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1075,7 +1111,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1102,7 +1138,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1124,7 +1160,7 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1145,13 +1181,16 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1182,11 +1221,11 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1203,20 +1242,30 @@ public class ImmutableObject2BooleanOpenHashMap extends AbstractObject2Boolea public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ByteOpenHashMap.java index 0e22bab..abf0d99 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ByteOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2ByteEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap o) { throw new UnsupportedOperationException(); } @Override - public Object2ByteMap.Entry first() { + public Object2ByteMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstByteValue()); } @Override - public Object2ByteMap.Entry last() { + public Object2ByteMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastByteValue()); } @Override - public Object2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap action) { @@ -902,30 +933,35 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2ByteOpenHashMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap extends AbstractObject2ByteMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2CharOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2CharOpenHashMap.java index 027799b..7775561 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2CharOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap extends AbstractObject2CharMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2CharEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap extends AbstractObject2CharMap o) { throw new UnsupportedOperationException(); } @Override - public Object2CharMap.Entry first() { + public Object2CharMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstCharValue()); } @Override - public Object2CharMap.Entry last() { + public Object2CharMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastCharValue()); } @Override - public Object2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap action) { @@ -902,30 +933,35 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap extends AbstractObject2CharMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2CharOpenHashMap extends AbstractObject2CharMap extends AbstractObject2CharMap extends AbstractObject2CharMap extends AbstractObject2CharMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2DoubleOpenHashMap.java index 78e4be2..cdbb9f0 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2DoubleOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2DoubleMap; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM @Override public double putAndMoveToLast(T key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(T key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(T key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -349,7 +353,24 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2DoubleEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -499,24 +520,29 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM public boolean moveToLast(Object2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2DoubleMap.Entry first() { + public Object2DoubleMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstDoubleValue()); } @Override - public Object2DoubleMap.Entry last() { + public Object2DoubleMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastDoubleValue()); } @Override - public Object2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -902,30 +933,35 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1054,7 +1090,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1150,13 +1186,16 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1187,11 +1226,11 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1208,20 +1247,30 @@ public class ImmutableObject2DoubleOpenHashMap extends AbstractObject2DoubleM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2FloatOpenHashMap.java index 2a99403..ffe7a8b 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2FloatOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap @Override public float putAndMoveToLast(T key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(T key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(T key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -349,7 +353,24 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2FloatEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -499,24 +520,29 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap public boolean moveToLast(Object2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2FloatMap.Entry first() { + public Object2FloatMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstFloatValue()); } @Override - public Object2FloatMap.Entry last() { + public Object2FloatMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastFloatValue()); } @Override - public Object2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -902,30 +933,35 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1054,7 +1090,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1150,13 +1186,16 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1187,11 +1226,11 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1208,20 +1247,30 @@ public class ImmutableObject2FloatOpenHashMap extends AbstractObject2FloatMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2IntOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2IntOpenHashMap.java index b0ab5b4..feff8fd 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2IntOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2IntMap; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap @Override public int putAndMoveToLast(T key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(T key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(T key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -349,7 +353,24 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2IntEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -499,24 +520,29 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap public boolean moveToLast(Object2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2IntMap.Entry first() { + public Object2IntMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstIntValue()); } @Override - public Object2IntMap.Entry last() { + public Object2IntMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastIntValue()); } @Override - public Object2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -902,30 +933,35 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1054,7 +1090,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1150,13 +1186,16 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1187,11 +1226,11 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1208,20 +1247,30 @@ public class ImmutableObject2IntOpenHashMap extends AbstractObject2IntMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2LongOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2LongOpenHashMap.java index c611f80..f9697b4 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2LongOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2LongMap; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap extends AbstractObject2LongMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2LongEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap extends AbstractObject2LongMap o) { throw new UnsupportedOperationException(); } @Override - public Object2LongMap.Entry first() { + public Object2LongMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstLongValue()); } @Override - public Object2LongMap.Entry last() { + public Object2LongMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastLongValue()); } @Override - public Object2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap action) { @@ -902,30 +933,35 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap extends AbstractObject2LongMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2LongOpenHashMap extends AbstractObject2LongMap extends AbstractObject2LongMap extends AbstractObject2LongMap extends AbstractObject2LongMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ObjectOpenHashMap.java index 6e6aa9c..bed2aef 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ObjectOpenHashMap.java @@ -17,7 +17,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ObjectOrderedMap; import speiger.src.collections.objects.maps.abstracts.AbstractObject2ObjectMap; import speiger.src.collections.objects.maps.interfaces.Object2ObjectMap; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -56,7 +56,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient ObjectCollection valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -218,6 +218,10 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje @Override public V putAndMoveToLast(T key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(T key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(T key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -300,7 +304,24 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje public V lastValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2ObjectEntrySet() { @@ -315,7 +336,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -442,24 +463,29 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje public boolean moveToLast(Object2ObjectMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2ObjectMap.Entry first() { + public Object2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstValue()); } @Override - public Object2ObjectMap.Entry last() { + public Object2ObjectMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastValue()); } @Override - public Object2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -469,7 +495,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -685,7 +711,12 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -705,20 +736,20 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -845,31 +876,36 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -998,7 +1034,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1024,7 +1060,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1051,7 +1087,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1073,7 +1109,7 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1094,13 +1130,16 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1131,11 +1170,11 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1152,20 +1191,30 @@ public class ImmutableObject2ObjectOpenHashMap extends AbstractObject2Obje public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ShortOpenHashMap.java index 67dfc25..10cc1cc 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/immutable/ImmutableObject2ShortOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -64,7 +64,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap /** KeySet cache */ protected transient ObjectOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap @Override public short putAndMoveToLast(T key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(T key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(T key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -349,7 +353,24 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Object2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> object2ShortEntrySet() { @@ -364,7 +385,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -499,24 +520,29 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap public boolean moveToLast(Object2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Object2ShortMap.Entry first() { + public Object2ShortMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstShortValue()); } @Override - public Object2ShortMap.Entry last() { + public Object2ShortMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastShortValue()); } @Override - public Object2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -526,7 +552,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap public void clear() { throw new UnsupportedOperationException(); } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { @@ -902,30 +933,35 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableObject2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableObject2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1054,7 +1090,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -1080,7 +1116,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -1107,7 +1143,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -1129,7 +1165,7 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1150,13 +1186,16 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { @@ -1187,11 +1226,11 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1208,20 +1247,30 @@ public class ImmutableObject2ShortOpenHashMap extends AbstractObject2ShortMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2BooleanMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2BooleanMap.java index 06c3b52..5198aeb 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2BooleanMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2BooleanMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2BooleanOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanConsumer; import speiger.src.collections.booleans.lists.BooleanListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap return getDefaultReturnValue(); } + @Override + public boolean putFirst(T key, boolean value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public boolean putLast(T key, boolean value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap return values[lastIndex]; } + @Override + public Object2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = false; + return result; + } + + @Override + public Object2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = false; + return result; + } + @Override public ObjectOrderedSet> object2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } @Override - public Object2BooleanMap.Entry first() { + public Object2BooleanMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstBooleanValue()); } @Override - public Object2BooleanMap.Entry last() { + public Object2BooleanMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastBooleanValue()); } @Override - public Object2BooleanMap.Entry pollFirst() { + public Object2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstBooleanValue()); pollFirstKey(); return entry; } @Override - public Object2BooleanMap.Entry pollLast() { + public Object2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastBooleanValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2BooleanMap.this.size(); - } - + public int size() { return LinkedEnum2BooleanMap.this.size(); } @Override - public void clear() { - LinkedEnum2BooleanMap.this.clear(); + public void clear() { LinkedEnum2BooleanMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -753,16 +832,20 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2BooleanMap> extends Enum2BooleanMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ByteMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ByteMap.java index 6c92e70..e6a865a 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ByteMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ByteMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ByteOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteConsumer; import speiger.src.collections.bytes.lists.ByteListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple return getDefaultReturnValue(); } + @Override + public byte putFirst(T key, byte value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public byte putLast(T key, byte value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple return values[lastIndex]; } + @Override + public Object2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (byte)0; + return result; + } + + @Override + public Object2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (byte)0; + return result; + } + @Override public ObjectOrderedSet> object2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } @Override - public Object2ByteMap.Entry first() { + public Object2ByteMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstByteValue()); } @Override - public Object2ByteMap.Entry last() { + public Object2ByteMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastByteValue()); } @Override - public Object2ByteMap.Entry pollFirst() { + public Object2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstByteValue()); pollFirstKey(); return entry; } @Override - public Object2ByteMap.Entry pollLast() { + public Object2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastByteValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2ByteMap.this.size(); - } - + public int size() { return LinkedEnum2ByteMap.this.size(); } @Override - public void clear() { - LinkedEnum2ByteMap.this.clear(); + public void clear() { LinkedEnum2ByteMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastKey(); + return result; } - @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -753,16 +832,20 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2ByteMap> extends Enum2ByteMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2CharMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2CharMap.java index ca812c9..dcae37e 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2CharMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2CharMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2CharOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharConsumer; import speiger.src.collections.chars.lists.CharListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple return getDefaultReturnValue(); } + @Override + public char putFirst(T key, char value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public char putLast(T key, char value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple return values[lastIndex]; } + @Override + public Object2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (char)0; + return result; + } + + @Override + public Object2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (char)0; + return result; + } + @Override public ObjectOrderedSet> object2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } @Override - public Object2CharMap.Entry first() { + public Object2CharMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstCharValue()); } @Override - public Object2CharMap.Entry last() { + public Object2CharMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastCharValue()); } @Override - public Object2CharMap.Entry pollFirst() { + public Object2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstCharValue()); pollFirstKey(); return entry; } @Override - public Object2CharMap.Entry pollLast() { + public Object2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastCharValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2CharMap.this.size(); - } - + public int size() { return LinkedEnum2CharMap.this.size(); } @Override - public void clear() { - LinkedEnum2CharMap.this.clear(); + public void clear() { LinkedEnum2CharMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastKey(); + return result; } - @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -753,16 +832,20 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2CharMap> extends Enum2CharMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2DoubleMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2DoubleMap.java index d1225d0..8811b18 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2DoubleMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2DoubleMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2DoubleOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleConsumer; import speiger.src.collections.doubles.lists.DoubleListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i return getDefaultReturnValue(); } + @Override + public double putFirst(T key, double value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public double putLast(T key, double value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i return values[lastIndex]; } + @Override + public Object2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0D; + return result; + } + + @Override + public Object2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0D; + return result; + } + @Override public ObjectOrderedSet> object2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } @Override - public Object2DoubleMap.Entry first() { + public Object2DoubleMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstDoubleValue()); } @Override - public Object2DoubleMap.Entry last() { + public Object2DoubleMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastDoubleValue()); } @Override - public Object2DoubleMap.Entry pollFirst() { + public Object2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstDoubleValue()); pollFirstKey(); return entry; } @Override - public Object2DoubleMap.Entry pollLast() { + public Object2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastDoubleValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2DoubleMap.this.size(); - } - + public int size() { return LinkedEnum2DoubleMap.this.size(); } @Override - public void clear() { - LinkedEnum2DoubleMap.this.clear(); + public void clear() { LinkedEnum2DoubleMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -753,16 +832,20 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2DoubleMap> extends Enum2DoubleMap i public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2FloatMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2FloatMap.java index 2f8570d..803655a 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2FloatMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2FloatMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2FloatOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatConsumer; import speiger.src.collections.floats.lists.FloatListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp return getDefaultReturnValue(); } + @Override + public float putFirst(T key, float value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public float putLast(T key, float value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp return values[lastIndex]; } + @Override + public Object2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0F; + return result; + } + + @Override + public Object2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0F; + return result; + } + @Override public ObjectOrderedSet> object2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } @Override - public Object2FloatMap.Entry first() { + public Object2FloatMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstFloatValue()); } @Override - public Object2FloatMap.Entry last() { + public Object2FloatMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastFloatValue()); } @Override - public Object2FloatMap.Entry pollFirst() { + public Object2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstFloatValue()); pollFirstKey(); return entry; } @Override - public Object2FloatMap.Entry pollLast() { + public Object2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastFloatValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2FloatMap.this.size(); - } - + public int size() { return LinkedEnum2FloatMap.this.size(); } @Override - public void clear() { - LinkedEnum2FloatMap.this.clear(); + public void clear() { LinkedEnum2FloatMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastKey(); + return result; } - @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -753,16 +832,20 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2FloatMap> extends Enum2FloatMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2IntMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2IntMap.java index 16b3a58..0d2447c 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2IntMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2IntMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2IntOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntConsumer; import speiger.src.collections.ints.lists.IntListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme return getDefaultReturnValue(); } + @Override + public int putFirst(T key, int value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public int putLast(T key, int value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme return values[lastIndex]; } + @Override + public Object2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0; + return result; + } + + @Override + public Object2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0; + return result; + } + @Override public ObjectOrderedSet> object2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } @Override - public Object2IntMap.Entry first() { + public Object2IntMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstIntValue()); } @Override - public Object2IntMap.Entry last() { + public Object2IntMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastIntValue()); } @Override - public Object2IntMap.Entry pollFirst() { + public Object2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstIntValue()); pollFirstKey(); return entry; } @Override - public Object2IntMap.Entry pollLast() { + public Object2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastIntValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2IntMap.this.size(); - } - + public int size() { return LinkedEnum2IntMap.this.size(); } @Override - public void clear() { - LinkedEnum2IntMap.this.clear(); + public void clear() { LinkedEnum2IntMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastKey(); + return result; } - @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -753,16 +832,20 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2IntMap> extends Enum2IntMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2LongMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2LongMap.java index d97d3fe..fee536c 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2LongMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2LongMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2LongOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongConsumer; import speiger.src.collections.longs.lists.LongListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple return getDefaultReturnValue(); } + @Override + public long putFirst(T key, long value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public long putLast(T key, long value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple return values[lastIndex]; } + @Override + public Object2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0L; + return result; + } + + @Override + public Object2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = 0L; + return result; + } + @Override public ObjectOrderedSet> object2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } @Override - public Object2LongMap.Entry first() { + public Object2LongMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstLongValue()); } @Override - public Object2LongMap.Entry last() { + public Object2LongMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastLongValue()); } @Override - public Object2LongMap.Entry pollFirst() { + public Object2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstLongValue()); pollFirstKey(); return entry; } @Override - public Object2LongMap.Entry pollLast() { + public Object2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastLongValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2LongMap.this.size(); - } - + public int size() { return LinkedEnum2LongMap.this.size(); } @Override - public void clear() { - LinkedEnum2LongMap.this.clear(); + public void clear() { LinkedEnum2LongMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastKey(); + return result; } - @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -753,16 +832,20 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2LongMap> extends Enum2LongMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ObjectMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ObjectMap.java index 87f2095..be46e75 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ObjectMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ObjectMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ObjectOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; /** @@ -183,6 +183,28 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap, V> extends Enum2ObjectMap firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = null; + return result; + } + + @Override + public Object2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = null; + return result; + } + @Override public ObjectOrderedSet> object2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -292,9 +350,9 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -398,24 +456,24 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap first() { + public Object2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstValue()); } @Override - public Object2ObjectMap.Entry last() { + public Object2ObjectMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastValue()); } @Override - public Object2ObjectMap.Entry pollFirst() { + public Object2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstValue()); pollFirstKey(); return entry; } @Override - public Object2ObjectMap.Entry pollLast() { + public Object2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastValue()); pollLastKey(); return entry; @@ -423,7 +481,12 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -433,7 +496,7 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -545,7 +608,12 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -566,22 +634,22 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap, V> extends Enum2ObjectMap { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2ObjectMap.this.size(); - } - + public int size() { return LinkedEnum2ObjectMap.this.size(); } @Override - public void clear() { - LinkedEnum2ObjectMap.this.clear(); + public void clear() { LinkedEnum2ObjectMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastKey(); + return result; } - @Override public void forEach(Consumer action) { int index = firstIndex; @@ -636,7 +715,7 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -663,7 +742,7 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -693,7 +772,7 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -715,7 +794,7 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -736,16 +815,20 @@ public class LinkedEnum2ObjectMap, V> extends Enum2ObjectMap, V> extends Enum2ObjectMap, V> extends Enum2ObjectMap> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ShortMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ShortMap.java index fe17fab..2257c26 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ShortMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/LinkedEnum2ShortMap.java @@ -13,7 +13,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ShortOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortConsumer; import speiger.src.collections.shorts.lists.ShortListIterator; @@ -201,6 +201,28 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp return getDefaultReturnValue(); } + @Override + public short putFirst(T key, short value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToFirstIndex(index); + return getDefaultReturnValue(); + } + + @Override + public short putLast(T key, short value) { + int index = key.ordinal(); + if(isSet(index)) return values[index]; + set(index); + values[index] = value; + onNodeAdded(index); + moveToLastIndex(index); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(T key) { int index = key.ordinal(); @@ -297,6 +319,42 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp return values[lastIndex]; } + @Override + public Object2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Object2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Object2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (short)0; + return result; + } + + @Override + public Object2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + firstIndex = (int)links[pos]; + if(0 <= firstIndex) links[firstIndex] |= 0xFFFFFFFF00000000L; + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + values[result.getKey().ordinal()] = (short)0; + return result; + } + @Override public ObjectOrderedSet> object2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -310,9 +368,9 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -416,24 +474,24 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } @Override - public Object2ShortMap.Entry first() { + public Object2ShortMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstShortValue()); } @Override - public Object2ShortMap.Entry last() { + public Object2ShortMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastShortValue()); } @Override - public Object2ShortMap.Entry pollFirst() { + public Object2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstShortValue()); pollFirstKey(); return entry; } @Override - public Object2ShortMap.Entry pollLast() { + public Object2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastShortValue()); pollLastKey(); return entry; @@ -441,7 +499,12 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -451,7 +514,7 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -563,7 +626,12 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp @Override public ObjectListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -584,22 +652,22 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } @Override - public T first() { + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { + public T getLast() { return lastKey(); } @Override - public T pollLast() { + public T removeLast() { return pollLastKey(); } @@ -614,32 +682,43 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return LinkedEnum2ShortMap.this.size(); - } - + public int size() { return LinkedEnum2ShortMap.this.size(); } @Override - public void clear() { - LinkedEnum2ShortMap.this.clear(); + public void clear() { LinkedEnum2ShortMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastKey(); + return result; } - @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -653,7 +732,7 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(T from) { super(from); } @@ -680,7 +759,7 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(T from) { super(from); } @@ -710,7 +789,7 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(T from) { super(from); } @@ -732,7 +811,7 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -753,16 +832,20 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(T from) { + this.forward = true; previous = from.ordinal() - 1; index = from.ordinal(); next = from.ordinal(); @@ -770,11 +853,11 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -809,20 +892,30 @@ public class LinkedEnum2ShortMap> extends Enum2ShortMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2BooleanArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2BooleanArrayMap.java index a970ee4..23aceff 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2BooleanArrayMap.java @@ -21,7 +21,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2BooleanOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -54,7 +54,7 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -198,6 +198,27 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl return lastValue; } + @Override + public boolean putFirst(T key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(T key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -307,6 +328,34 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl return result; } + @Override + public Object2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean rem(T key) { int index = findIndex(key); @@ -364,7 +413,7 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -676,24 +725,24 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } @Override - public Object2BooleanMap.Entry first() { + public Object2BooleanMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstBooleanValue()); } @Override - public Object2BooleanMap.Entry last() { + public Object2BooleanMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastBooleanValue()); } @Override - public Object2BooleanMap.Entry pollFirst() { + public Object2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstBooleanValue()); pollFirstKey(); return entry; } @Override - public Object2BooleanMap.Entry pollLast() { + public Object2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastBooleanValue()); pollLastKey(); return entry; @@ -701,7 +750,12 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -711,7 +765,7 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -908,7 +962,9 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl @Override public boolean moveToLast(T o) { return Object2BooleanArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -916,13 +972,13 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl @Override public void clear() { Object2BooleanArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1019,32 +1075,43 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2BooleanArrayMap.this.size(); - } - + public int size() { return Object2BooleanArrayMap.this.size(); } @Override - public void clear() { - Object2BooleanArrayMap.this.clear(); + public void clear() { Object2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1133,10 +1200,8 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2BooleanMap.Entry next() { @@ -1159,11 +1224,8 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2BooleanMap.Entry next() { @@ -1190,11 +1252,8 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1214,6 +1273,9 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1232,23 +1294,37 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1261,26 +1337,42 @@ public class Object2BooleanArrayMap extends AbstractObject2BooleanMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ByteArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ByteArrayMap.java index 15bbb78..bc1fe39 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ByteArrayMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ByteOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -55,7 +55,7 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements return lastValue; } + @Override + public byte putFirst(T key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(T key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements return result; } + @Override + public Object2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } @Override - public Object2ByteMap.Entry first() { + public Object2ByteMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstByteValue()); } @Override - public Object2ByteMap.Entry last() { + public Object2ByteMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastByteValue()); } @Override - public Object2ByteMap.Entry pollFirst() { + public Object2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstByteValue()); pollFirstKey(); return entry; } @Override - public Object2ByteMap.Entry pollLast() { + public Object2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastByteValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements @Override public boolean moveToLast(T o) { return Object2ByteArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements @Override public void clear() { Object2ByteArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ByteArrayMap.this.size(); - } - + public int size() { return Object2ByteArrayMap.this.size(); } @Override - public void clear() { - Object2ByteArrayMap.this.clear(); + public void clear() { Object2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2ByteMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2ByteMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2ByteArrayMap extends AbstractObject2ByteMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2CharArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2CharArrayMap.java index 290796f..1afec16 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2CharArrayMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2CharOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -55,7 +55,7 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements return lastValue; } + @Override + public char putFirst(T key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(T key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements return result; } + @Override + public Object2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } @Override - public Object2CharMap.Entry first() { + public Object2CharMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstCharValue()); } @Override - public Object2CharMap.Entry last() { + public Object2CharMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastCharValue()); } @Override - public Object2CharMap.Entry pollFirst() { + public Object2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstCharValue()); pollFirstKey(); return entry; } @Override - public Object2CharMap.Entry pollLast() { + public Object2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastCharValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements @Override public boolean moveToLast(T o) { return Object2CharArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements @Override public void clear() { Object2CharArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2CharArrayMap.this.size(); - } - + public int size() { return Object2CharArrayMap.this.size(); } @Override - public void clear() { - Object2CharArrayMap.this.clear(); + public void clear() { Object2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2CharMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2CharMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2CharArrayMap extends AbstractObject2CharMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2DoubleArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2DoubleArrayMap.java index 44d9360..97f391c 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2DoubleArrayMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2DoubleOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -55,7 +55,7 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem return lastValue; } + @Override + public double putFirst(T key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(T key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem return result; } + @Override + public Object2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } @Override - public Object2DoubleMap.Entry first() { + public Object2DoubleMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstDoubleValue()); } @Override - public Object2DoubleMap.Entry last() { + public Object2DoubleMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastDoubleValue()); } @Override - public Object2DoubleMap.Entry pollFirst() { + public Object2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstDoubleValue()); pollFirstKey(); return entry; } @Override - public Object2DoubleMap.Entry pollLast() { + public Object2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastDoubleValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem @Override public boolean moveToLast(T o) { return Object2DoubleArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem @Override public void clear() { Object2DoubleArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2DoubleArrayMap.this.size(); - } - + public int size() { return Object2DoubleArrayMap.this.size(); } @Override - public void clear() { - Object2DoubleArrayMap.this.clear(); + public void clear() { Object2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2DoubleMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2DoubleMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2DoubleArrayMap extends AbstractObject2DoubleMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2FloatArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2FloatArrayMap.java index c1bb770..15bf68d 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2FloatArrayMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2FloatOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -55,7 +55,7 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen return lastValue; } + @Override + public float putFirst(T key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(T key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen return result; } + @Override + public Object2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } @Override - public Object2FloatMap.Entry first() { + public Object2FloatMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstFloatValue()); } @Override - public Object2FloatMap.Entry last() { + public Object2FloatMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastFloatValue()); } @Override - public Object2FloatMap.Entry pollFirst() { + public Object2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstFloatValue()); pollFirstKey(); return entry; } @Override - public Object2FloatMap.Entry pollLast() { + public Object2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastFloatValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen @Override public boolean moveToLast(T o) { return Object2FloatArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen @Override public void clear() { Object2FloatArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2FloatArrayMap.this.size(); - } - + public int size() { return Object2FloatArrayMap.this.size(); } @Override - public void clear() { - Object2FloatArrayMap.this.clear(); + public void clear() { Object2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2FloatMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2FloatMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2FloatArrayMap extends AbstractObject2FloatMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2IntArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2IntArrayMap.java index c0aef88..4b2e8ed 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2IntArrayMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2IntOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -55,7 +55,7 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O return lastValue; } + @Override + public int putFirst(T key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(T key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O return result; } + @Override + public Object2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } @Override - public Object2IntMap.Entry first() { + public Object2IntMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstIntValue()); } @Override - public Object2IntMap.Entry last() { + public Object2IntMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastIntValue()); } @Override - public Object2IntMap.Entry pollFirst() { + public Object2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstIntValue()); pollFirstKey(); return entry; } @Override - public Object2IntMap.Entry pollLast() { + public Object2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastIntValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O @Override public boolean moveToLast(T o) { return Object2IntArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O @Override public void clear() { Object2IntArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2IntArrayMap.this.size(); - } - + public int size() { return Object2IntArrayMap.this.size(); } @Override - public void clear() { - Object2IntArrayMap.this.clear(); + public void clear() { Object2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2IntMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2IntMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2IntArrayMap extends AbstractObject2IntMap implements O public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2LongArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2LongArrayMap.java index e560fce..1f3d5d4 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2LongArrayMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2LongOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -55,7 +55,7 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements return lastValue; } + @Override + public long putFirst(T key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(T key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements return result; } + @Override + public Object2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } @Override - public Object2LongMap.Entry first() { + public Object2LongMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstLongValue()); } @Override - public Object2LongMap.Entry last() { + public Object2LongMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastLongValue()); } @Override - public Object2LongMap.Entry pollFirst() { + public Object2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstLongValue()); pollFirstKey(); return entry; } @Override - public Object2LongMap.Entry pollLast() { + public Object2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastLongValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements @Override public boolean moveToLast(T o) { return Object2LongArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements @Override public void clear() { Object2LongArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2LongArrayMap.this.size(); - } - + public int size() { return Object2LongArrayMap.this.size(); } @Override - public void clear() { - Object2LongArrayMap.this.clear(); + public void clear() { Object2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2LongMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2LongMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2LongArrayMap extends AbstractObject2LongMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ObjectArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ObjectArrayMap.java index 5dc393c..8921e96 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ObjectArrayMap.java @@ -20,7 +20,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ObjectOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.utils.HashUtil; @@ -47,7 +47,7 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -168,6 +168,27 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap return lastValue; } + @Override + public V putFirst(T key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(T key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -272,6 +293,34 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap return result; } + @Override + public Object2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V rem(T key) { int index = findIndex(key); @@ -321,7 +370,7 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -572,24 +621,24 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } @Override - public Object2ObjectMap.Entry first() { + public Object2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstValue()); } @Override - public Object2ObjectMap.Entry last() { + public Object2ObjectMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastValue()); } @Override - public Object2ObjectMap.Entry pollFirst() { + public Object2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstValue()); pollFirstKey(); return entry; } @Override - public Object2ObjectMap.Entry pollLast() { + public Object2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastValue()); pollLastKey(); return entry; @@ -597,7 +646,12 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -607,7 +661,7 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -804,7 +858,9 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap @Override public boolean moveToLast(T o) { return Object2ObjectArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -812,13 +868,13 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap @Override public void clear() { Object2ObjectArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -915,32 +971,43 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ObjectArrayMap.this.size(); - } - + public int size() { return Object2ObjectArrayMap.this.size(); } @Override - public void clear() { - Object2ObjectArrayMap.this.clear(); + public void clear() { Object2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1029,10 +1096,8 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2ObjectMap.Entry next() { @@ -1055,11 +1120,8 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2ObjectMap.Entry next() { @@ -1086,11 +1148,8 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1110,6 +1169,9 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1128,23 +1190,37 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1157,26 +1233,42 @@ public class Object2ObjectArrayMap extends AbstractObject2ObjectMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ShortArrayMap.java b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ShortArrayMap.java index c76e08d..c28ec3f 100644 --- a/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/impl/misc/Object2ShortArrayMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.objects.maps.interfaces.Object2ShortOrderedMap; import speiger.src.collections.objects.sets.AbstractObjectSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; @@ -55,7 +55,7 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen /** KeySet cache */ protected ObjectOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -221,6 +221,27 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen return lastValue; } + @Override + public short putFirst(T key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(T key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(T key) { int index = findIndex(key); @@ -330,6 +351,34 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen return result; } + @Override + public Object2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Object2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Object2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Object2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short rem(T key) { int index = findIndex(key); @@ -387,7 +436,7 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -699,24 +748,24 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } @Override - public Object2ShortMap.Entry first() { + public Object2ShortMap.Entry getFirst() { return new BasicEntry<>(firstKey(), firstShortValue()); } @Override - public Object2ShortMap.Entry last() { + public Object2ShortMap.Entry getLast() { return new BasicEntry<>(lastKey(), lastShortValue()); } @Override - public Object2ShortMap.Entry pollFirst() { + public Object2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstKey(), firstShortValue()); pollFirstKey(); return entry; } @Override - public Object2ShortMap.Entry pollLast() { + public Object2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastKey(), lastShortValue()); pollLastKey(); return entry; @@ -724,7 +773,12 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -734,7 +788,7 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -931,7 +985,9 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen @Override public boolean moveToLast(T o) { return Object2ShortArrayMap.this.moveToLast(o); } @Override - public ObjectListIterator iterator() { return new KeyIterator(); } + public ObjectListIterator iterator() { return new KeyIterator(true); } + @Override + public ObjectListIterator reverseIterator() { return new KeyIterator(false); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { return new KeyIterator(fromElement); } @Override @@ -939,13 +995,13 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen @Override public void clear() { Object2ShortArrayMap.this.clear(); } @Override - public T first() { return firstKey(); } + public T getFirst() { return firstKey(); } @Override - public T pollFirst() { return pollFirstKey(); } + public T removeFirst() { return pollFirstKey(); } @Override - public T last() { return lastKey(); } + public T getLast() { return lastKey(); } @Override - public T pollLast() { return pollLastKey(); } + public T removeLast() { return pollLastKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1042,32 +1098,43 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Object2ShortArrayMap.this.size(); - } - + public int size() { return Object2ShortArrayMap.this.size(); } @Override - public void clear() { - Object2ShortArrayMap.this.clear(); + public void clear() { Object2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1156,10 +1223,8 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(T from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(T element) { super(element); } @Override public Object2ShortMap.Entry next() { @@ -1182,11 +1247,8 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(T from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(T element) { super(element); } @Override public Object2ShortMap.Entry next() { @@ -1213,11 +1275,8 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } private class KeyIterator extends MapIterator implements ObjectListIterator { - public KeyIterator() {} - public KeyIterator(T element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(T element) { super(element); } @Override public T previous() { @@ -1237,6 +1296,9 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(T element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1255,23 +1317,37 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(T element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1284,26 +1360,42 @@ public class Object2ShortArrayMap extends AbstractObject2ShortMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanMap.java index 22316bb..0d0c930 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanMap.java @@ -96,7 +96,7 @@ public interface Object2BooleanMap extends Map, Predicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanOrderedMap.java index 8fe5ccb..33abf0d 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2BooleanMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2BooleanOrderedMap extends Object2BooleanMap */ public boolean putAndMoveToLast(T key, boolean 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 boolean putFirst(T key, boolean 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 boolean putLast(T key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2BooleanOrderedMap extends Object2BooleanMap */ public boolean lastBooleanValue(); + + public Object2BooleanMap.Entry firstEntry(); + + public Object2BooleanMap.Entry lastEntry(); + + public Object2BooleanMap.Entry pollFirstEntry(); + + public Object2BooleanMap.Entry pollLastEntry(); @Override public Object2BooleanOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet> object2BooleanEntrySet(); + public default Object2BooleanOrderedMap reversed() { return new AbstractObject2BooleanMap.ReversedObject2BooleanOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteMap.java index e9e2cf1..350d893 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteMap.java @@ -96,7 +96,7 @@ public interface Object2ByteMap extends Map, ToByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteOrderedMap.java index bbaacbf..52f1970 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2ByteMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2ByteOrderedMap extends Object2ByteMap */ public byte putAndMoveToLast(T key, byte 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 byte putFirst(T key, byte 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 byte putLast(T key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2ByteOrderedMap extends Object2ByteMap */ public byte lastByteValue(); + + public Object2ByteMap.Entry firstEntry(); + + public Object2ByteMap.Entry lastEntry(); + + public Object2ByteMap.Entry pollFirstEntry(); + + public Object2ByteMap.Entry pollLastEntry(); @Override public Object2ByteOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet> object2ByteEntrySet(); + public default Object2ByteOrderedMap reversed() { return new AbstractObject2ByteMap.ReversedObject2ByteOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharMap.java index 9703047..a327bdf 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharMap.java @@ -96,7 +96,7 @@ public interface Object2CharMap extends Map, ToCharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharOrderedMap.java index 8547f4a..68c5aa0 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2CharMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2CharOrderedMap extends Object2CharMap */ public char putAndMoveToLast(T key, char 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 char putFirst(T key, char 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 char putLast(T key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2CharOrderedMap extends Object2CharMap */ public char lastCharValue(); + + public Object2CharMap.Entry firstEntry(); + + public Object2CharMap.Entry lastEntry(); + + public Object2CharMap.Entry pollFirstEntry(); + + public Object2CharMap.Entry pollLastEntry(); @Override public Object2CharOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet> object2CharEntrySet(); + public default Object2CharOrderedMap reversed() { return new AbstractObject2CharMap.ReversedObject2CharOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleMap.java index 090d645..62e79b7 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleMap.java @@ -96,7 +96,7 @@ public interface Object2DoubleMap extends Map, ToDoubleFunction * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleOrderedMap.java index 1347323..419ae4e 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2DoubleMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2DoubleOrderedMap extends Object2DoubleMap */ public double putAndMoveToLast(T key, double 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 double putFirst(T key, double 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 double putLast(T key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2DoubleOrderedMap extends Object2DoubleMap */ public double lastDoubleValue(); + + public Object2DoubleMap.Entry firstEntry(); + + public Object2DoubleMap.Entry lastEntry(); + + public Object2DoubleMap.Entry pollFirstEntry(); + + public Object2DoubleMap.Entry pollLastEntry(); @Override public Object2DoubleOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet> object2DoubleEntrySet(); + public default Object2DoubleOrderedMap reversed() { return new AbstractObject2DoubleMap.ReversedObject2DoubleOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatMap.java index 29b9a8a..dcb1a80 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatMap.java @@ -96,7 +96,7 @@ public interface Object2FloatMap extends Map, ToFloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatOrderedMap.java index 05cf4f5..b2dd082 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2FloatMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2FloatOrderedMap extends Object2FloatMap */ public float putAndMoveToLast(T key, float 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 float putFirst(T key, float 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 float putLast(T key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2FloatOrderedMap extends Object2FloatMap */ public float lastFloatValue(); + + public Object2FloatMap.Entry firstEntry(); + + public Object2FloatMap.Entry lastEntry(); + + public Object2FloatMap.Entry pollFirstEntry(); + + public Object2FloatMap.Entry pollLastEntry(); @Override public Object2FloatOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet> object2FloatEntrySet(); + public default Object2FloatOrderedMap reversed() { return new AbstractObject2FloatMap.ReversedObject2FloatOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntMap.java index c717f92..a60ddc5 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntMap.java @@ -96,7 +96,7 @@ public interface Object2IntMap extends Map, ToIntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntOrderedMap.java index 454ff9f..fcc1e70 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2IntMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2IntOrderedMap extends Object2IntMap */ public int putAndMoveToLast(T key, int 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 int putFirst(T key, int 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 int putLast(T key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2IntOrderedMap extends Object2IntMap */ public int lastIntValue(); + + public Object2IntMap.Entry firstEntry(); + + public Object2IntMap.Entry lastEntry(); + + public Object2IntMap.Entry pollFirstEntry(); + + public Object2IntMap.Entry pollLastEntry(); @Override public Object2IntOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet> object2IntEntrySet(); + public default Object2IntOrderedMap reversed() { return new AbstractObject2IntMap.ReversedObject2IntOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongMap.java index 9ff0463..dd74efa 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongMap.java @@ -96,7 +96,7 @@ public interface Object2LongMap extends Map, ToLongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongOrderedMap.java index ba89163..cf2cefc 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2LongMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2LongOrderedMap extends Object2LongMap */ public long putAndMoveToLast(T key, long 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 long putFirst(T key, long 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 long putLast(T key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2LongOrderedMap extends Object2LongMap */ public long lastLongValue(); + + public Object2LongMap.Entry firstEntry(); + + public Object2LongMap.Entry lastEntry(); + + public Object2LongMap.Entry pollFirstEntry(); + + public Object2LongMap.Entry pollLastEntry(); @Override public Object2LongOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet> object2LongEntrySet(); + public default Object2LongOrderedMap reversed() { return new AbstractObject2LongMap.ReversedObject2LongOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ObjectOrderedMap.java index f5fbf03..00aa457 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2ObjectMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -32,6 +34,26 @@ public interface Object2ObjectOrderedMap extends Object2ObjectMap */ public V putAndMoveToLast(T key, V 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 V putFirst(T key, V 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 V putLast(T key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Object2ObjectOrderedMap extends Object2ObjectMap */ public V lastValue(); + + public Object2ObjectMap.Entry firstEntry(); + + public Object2ObjectMap.Entry lastEntry(); + + public Object2ObjectMap.Entry pollFirstEntry(); + + public Object2ObjectMap.Entry pollLastEntry(); @Override public Object2ObjectOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> object2ObjectEntrySet(); + public default Object2ObjectOrderedMap reversed() { return new AbstractObject2ObjectMap.ReversedObject2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortMap.java index 2d3148f..f89d8d3 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortMap.java @@ -96,7 +96,7 @@ public interface Object2ShortMap extends Map, ToShortFunction * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortOrderedMap.java b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortOrderedMap.java index 38eeb4c..d46ba0f 100644 --- a/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/objects/maps/interfaces/Object2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.objects.maps.interfaces; import speiger.src.collections.objects.utils.maps.Object2ShortMaps; +import speiger.src.collections.objects.maps.abstracts.AbstractObject2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; /** @@ -31,6 +33,26 @@ public interface Object2ShortOrderedMap extends Object2ShortMap */ public short putAndMoveToLast(T key, short 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 short putFirst(T key, short 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 short putLast(T key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Object2ShortOrderedMap extends Object2ShortMap */ public short lastShortValue(); + + public Object2ShortMap.Entry firstEntry(); + + public Object2ShortMap.Entry lastEntry(); + + public Object2ShortMap.Entry pollFirstEntry(); + + public Object2ShortMap.Entry pollLastEntry(); @Override public Object2ShortOrderedMap copy(); @Override public ObjectOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet> object2ShortEntrySet(); + public default Object2ShortOrderedMap reversed() { return new AbstractObject2ShortMap.ReversedObject2ShortOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/sets/AbstractObjectSet.java b/src/main/java/speiger/src/collections/objects/sets/AbstractObjectSet.java index e9b6f4e..323a240 100644 --- a/src/main/java/speiger/src/collections/objects/sets/AbstractObjectSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/AbstractObjectSet.java @@ -4,6 +4,7 @@ import java.util.Objects; import java.util.Set; import speiger.src.collections.objects.collections.AbstractObjectCollection; +import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.collections.ObjectIterator; /** @@ -43,4 +44,89 @@ public abstract class AbstractObjectSet extends AbstractObjectCollection i return false; } } + + public static class ReversedObjectOrderedSet extends AbstractObjectSet implements ObjectOrderedSet { + protected ObjectOrderedSet set; + + public ReversedObjectOrderedSet(ObjectOrderedSet set) { + this.set = set; + } + + @Override + public ReversedObjectOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public ObjectBidirectionalIterator iterator(T fromElement) { + return set.iterator(fromElement); + } + + @Override + public ObjectBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(Object o) { + return set.remove(o); + } + + @Override + public boolean add(T o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(T o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(T o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(T o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(T o) { + return set.moveToFirst(o); + } + + @Override + public T getFirst() { + return set.getLast(); + } + + @Override + public T removeFirst() { + return set.removeLast(); + } + + @Override + public T getLast() { + return set.getFirst(); + } + + @Override + public T removeLast() { + return set.removeFirst(); + } + + @Override + public ObjectOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/objects/sets/ImmutableObjectOpenHashSet.java b/src/main/java/speiger/src/collections/objects/sets/ImmutableObjectOpenHashSet.java index e3854b9..ec9949b 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ImmutableObjectOpenHashSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ImmutableObjectOpenHashSet.java @@ -258,22 +258,22 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen } @Override - public T first() { + public T getFirst() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { + public T getLast() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -395,7 +395,12 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen @Override public ObjectListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -448,16 +453,20 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen } private class SetIterator implements ObjectListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(T from) { + this.forward = true; if(from == null) { if(containsNull) { next = (int) links[nullIndex]; @@ -486,48 +495,60 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -536,8 +557,8 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen @Override public T previous() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -545,12 +566,22 @@ public class ImmutableObjectOpenHashSet extends AbstractObjectSet implemen @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectArraySet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectArraySet.java index 696b20b..b5c9c6f 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectArraySet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectArraySet.java @@ -193,13 +193,13 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd } @Override - public T first() { + public T getFirst() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public T last() { + public T getLast() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -295,7 +295,7 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd } @Override - public T pollFirst() { + public T removeFirst() { if(size == 0) throw new NoSuchElementException(); T result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -304,7 +304,7 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd } @Override - public T pollLast() { + public T removeLast() { if(size == 0) throw new NoSuchElementException(); size--; T result = data[size]; @@ -410,13 +410,18 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd @Override public ObjectBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public ObjectBidirectionalIterator iterator(T fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -458,45 +463,57 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd } private class SetIterator implements ObjectListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public T previous() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -516,15 +533,23 @@ public class ObjectArraySet extends AbstractObjectSet implements ObjectOrd @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenCustomHashSet.java index 1db09c9..6835972 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenCustomHashSet.java @@ -246,7 +246,7 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public boolean moveToFirst(T o) { - if(isEmpty() || strategy.equals(first(), o)) return false; + if(isEmpty() || strategy.equals(getFirst(), o)) return false; if(strategy.equals(o, null)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -268,7 +268,7 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public boolean moveToLast(T o) { - if(isEmpty() || strategy.equals(last(), o)) return false; + if(isEmpty() || strategy.equals(getLast(), o)) return false; if(strategy.equals(o, null)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -325,13 +325,13 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet } @Override - public T first() { + public T getFirst() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public T pollFirst() { + public T removeFirst() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -347,13 +347,13 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet } @Override - public T last() { + public T getLast() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public T pollLast() { + public T removeLast() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -624,7 +624,12 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public ObjectListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -649,16 +654,20 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet } private class SetIterator implements ObjectListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(T from) { + this.forward = true; if(strategy.equals(from, null)) { if(containsNull) { next = (int) links[nullIndex]; @@ -687,48 +696,60 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -777,8 +798,8 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public T previous() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -786,12 +807,22 @@ public class ObjectLinkedOpenCustomHashSet extends ObjectOpenCustomHashSet @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenHashSet.java index c5101e9..19103cd 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectLinkedOpenHashSet.java @@ -219,7 +219,7 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public boolean moveToFirst(T o) { - if(isEmpty() || Objects.equals(first(), o)) return false; + if(isEmpty() || Objects.equals(getFirst(), o)) return false; if(o == null) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -241,7 +241,7 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public boolean moveToLast(T o) { - if(isEmpty() || Objects.equals(last(), o)) return false; + if(isEmpty() || Objects.equals(getLast(), o)) return false; if(o == null) { if(containsNull) { moveToLastIndex(nullIndex); @@ -298,13 +298,13 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements } @Override - public T first() { + public T getFirst() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public T pollFirst() { + public T removeFirst() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -320,13 +320,13 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements } @Override - public T last() { + public T getLast() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public T pollLast() { + public T removeLast() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -597,7 +597,12 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public ObjectListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ObjectListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -622,16 +627,20 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements } private class SetIterator implements ObjectListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(T from) { + this.forward = true; if(from == null) { if(containsNull) { next = (int) links[nullIndex]; @@ -660,48 +669,60 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -750,8 +771,8 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public T previous() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -759,12 +780,22 @@ public class ObjectLinkedOpenHashSet extends ObjectOpenHashSet implements @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectNavigableSet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectNavigableSet.java index 0b252e6..2972deb 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectNavigableSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.collections.ObjectSplititerator; -import speiger.src.collections.objects.utils.ObjectSets; import speiger.src.collections.objects.utils.ObjectSplititerators; +import speiger.src.collections.objects.utils.ObjectSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectOrderedSet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectOrderedSet.java index c6bac7e..8d816a2 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectOrderedSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.objects.sets; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.collections.ObjectSplititerator; -import speiger.src.collections.objects.utils.ObjectSets; import speiger.src.collections.objects.utils.ObjectSplititerators; +import speiger.src.collections.objects.sets.AbstractObjectSet.ReversedObjectOrderedSet; +import speiger.src.collections.objects.utils.ObjectSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -50,6 +51,7 @@ public interface ObjectOrderedSet extends ObjectSet @Override public ObjectBidirectionalIterator iterator(); + public ObjectBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -70,23 +72,26 @@ public interface ObjectOrderedSet extends ObjectSet * A method to get the first element in the set * @return first element in the set */ - public T first(); + public T getFirst(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public T pollFirst(); + public T removeFirst(); /** * A method to get the last element in the set * @return last element in the set */ - public T last(); + public T getLast(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public T pollLast(); + public T removeLast(); + + public default ObjectOrderedSet reversed() { return new ReversedObjectOrderedSet<>(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/objects/sets/ObjectSet.java b/src/main/java/speiger/src/collections/objects/sets/ObjectSet.java index 7cd5236..f724114 100644 --- a/src/main/java/speiger/src/collections/objects/sets/ObjectSet.java +++ b/src/main/java/speiger/src/collections/objects/sets/ObjectSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.objects.collections.ObjectCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.collections.ObjectSplititerator; -import speiger.src.collections.objects.utils.ObjectSets; import speiger.src.collections.objects.utils.ObjectSplititerators; +import speiger.src.collections.objects.utils.ObjectSets; /** diff --git a/src/main/java/speiger/src/collections/objects/utils/ObjectCollections.java b/src/main/java/speiger/src/collections/objects/utils/ObjectCollections.java index 35fc66b..0dd2171 100644 --- a/src/main/java/speiger/src/collections/objects/utils/ObjectCollections.java +++ b/src/main/java/speiger/src/collections/objects/utils/ObjectCollections.java @@ -13,6 +13,7 @@ import java.util.function.Consumer; import speiger.src.collections.objects.collections.AbstractObjectCollection; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.ints.functions.consumer.IntObjectConsumer; @@ -50,6 +51,37 @@ public class ObjectCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection<>(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @param the keyType of elements maintained by this Collection + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static ObjectOrderedCollection unmodifiable(ObjectOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection<>(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @param the keyType of elements maintained by this Collection + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ObjectOrderedCollection synchronize(ObjectOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection<>(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. + * @param the keyType of elements maintained by this Collection + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ObjectOrderedCollection synchronize(ObjectOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection<>(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -547,6 +579,38 @@ public class ObjectCollections @Override public SingletonCollection copy() { return new SingletonCollection<>(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + * @param the keyType of elements maintained by this Collection + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements ObjectOrderedCollection { + ObjectOrderedCollection c; + + SynchronizedOrderedCollection(ObjectOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(ObjectOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ObjectOrderedCollection reversed() { return ObjectCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(T e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(T e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public T getFirst() { synchronized(mutex) { return this.c.getFirst(); } } + @Override + public T removeFirst() { synchronized(mutex) { return this.c.removeFirst(); } } + @Override + public T getLast() { synchronized(mutex) { return this.c.getLast(); } } + @Override + public T removeLast() { synchronized(mutex) { return this.c.removeLast(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -652,6 +716,34 @@ public class ObjectCollections public int count(Predicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + * @param the keyType of elements maintained by this Collection + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements ObjectOrderedCollection { + ObjectOrderedCollection c; + + UnmodifiableOrderedCollection(ObjectOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ObjectOrderedCollection reversed() { return ObjectCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(T e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(T e) { throw new UnsupportedOperationException(); } + @Override + public T getFirst() { return c.getFirst(); } + @Override + public T removeFirst() { throw new UnsupportedOperationException(); } + @Override + public T getLast() { return c.getLast(); } + @Override + public T removeLast() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/objects/utils/ObjectIterators.java b/src/main/java/speiger/src/collections/objects/utils/ObjectIterators.java index dac2bcb..b44fff6 100644 --- a/src/main/java/speiger/src/collections/objects/utils/ObjectIterators.java +++ b/src/main/java/speiger/src/collections/objects/utils/ObjectIterators.java @@ -45,7 +45,7 @@ public class ObjectIterators * @param the keyType of elements maintained by this Collection * @return an empty iterator */ - public static EmptyIterator empty() { + public static ObjectListIterator empty() { return (EmptyIterator)EMPTY; } @@ -495,7 +495,7 @@ public class ObjectIterators * @param the keyType of array that the operation should be applied * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(T... a) { + public static ObjectIterator wrap(T... a) { return wrap(a, 0, a.length); } @@ -507,7 +507,7 @@ public class ObjectIterators * @param the keyType of array that the operation should be applied * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(T[] a, int start, int end) { + public static ObjectIterator wrap(T[] a, int start, int end) { return new ArrayIterator<>(a, start, end); } diff --git a/src/main/java/speiger/src/collections/objects/utils/ObjectLists.java b/src/main/java/speiger/src/collections/objects/utils/ObjectLists.java index ad4eee4..d1ad7e9 100644 --- a/src/main/java/speiger/src/collections/objects/utils/ObjectLists.java +++ b/src/main/java/speiger/src/collections/objects/utils/ObjectLists.java @@ -29,7 +29,7 @@ public class ObjectLists * @param the keyType of elements maintained by this Collection * @return an empty list */ - public static EmptyList empty() { + public static ObjectList empty() { return (EmptyList)EMPTY; } diff --git a/src/main/java/speiger/src/collections/objects/utils/ObjectSets.java b/src/main/java/speiger/src/collections/objects/utils/ObjectSets.java index 42a090a..5219dd9 100644 --- a/src/main/java/speiger/src/collections/objects/utils/ObjectSets.java +++ b/src/main/java/speiger/src/collections/objects/utils/ObjectSets.java @@ -294,17 +294,19 @@ public class ObjectSets @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(s.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(s.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(T fromElement) { return ObjectIterators.unmodifiable(s.iterator(fromElement)); } @Override public ObjectOrderedSet copy() { return s.copy(); } @Override - public T first() { return s.first(); } + public T getFirst() { return s.getFirst(); } @Override - public T pollFirst() { throw new UnsupportedOperationException(); } + public T removeFirst() { throw new UnsupportedOperationException(); } @Override - public T last() { return s.last(); } + public T getLast() { return s.getLast(); } @Override - public T pollLast() { throw new UnsupportedOperationException(); } + public T removeLast() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements ObjectSortedSet @@ -543,17 +545,19 @@ public class ObjectSets @Override public ObjectBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public ObjectBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public ObjectBidirectionalIterator iterator(T fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public ObjectOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public T first() { synchronized(mutex) { return s.first(); } } + public T getFirst() { synchronized(mutex) { return s.getFirst(); } } @Override - public T pollFirst() { synchronized(mutex) { return s.pollFirst(); } } + public T removeFirst() { synchronized(mutex) { return s.removeFirst(); } } @Override - public T last() { synchronized(mutex) { return s.last(); } } + public T getLast() { synchronized(mutex) { return s.getLast(); } } @Override - public T pollLast() { synchronized(mutex) { return s.pollLast(); } } + public T removeLast() { synchronized(mutex) { return s.removeLast(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2BooleanMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2BooleanMaps.java index 3b995da..fa5b0be 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2BooleanMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -441,6 +442,10 @@ public class Object2BooleanMaps @Override public boolean putAndMoveToLast(T key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(T key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(T key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -461,13 +466,25 @@ public class Object2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Object2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2BooleanOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet> object2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2BooleanEntrySet()); @@ -618,15 +635,17 @@ public class Object2BooleanMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2BooleanMap.Entry first() { return set.first(); } + public Object2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2BooleanMap.Entry last() { return set.last(); } + public Object2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Object2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -748,6 +767,10 @@ public class Object2BooleanMaps @Override public boolean putAndMoveToLast(T key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(T key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(T key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -768,13 +791,25 @@ public class Object2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Object2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet> object2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ByteMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ByteMaps.java index 670a778..ffb55aa 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ByteMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ByteMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -449,6 +450,10 @@ public class Object2ByteMaps @Override public byte putAndMoveToLast(T key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(T key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(T key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Object2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2ByteOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2ByteEntrySet()); @@ -630,15 +647,17 @@ public class Object2ByteMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2ByteMap.Entry first() { return set.first(); } + public Object2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ByteMap.Entry last() { return set.last(); } + public Object2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Object2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2ByteMaps @Override public byte putAndMoveToLast(T key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(T key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(T key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Object2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2CharMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2CharMaps.java index 9a7d2f7..eb35cf8 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2CharMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2CharMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -449,6 +450,10 @@ public class Object2CharMaps @Override public char putAndMoveToLast(T key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(T key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(T key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Object2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2CharOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet> object2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2CharEntrySet()); @@ -630,15 +647,17 @@ public class Object2CharMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2CharMap.Entry first() { return set.first(); } + public Object2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2CharMap.Entry last() { return set.last(); } + public Object2CharMap.Entry getLast() { return set.getLast(); } @Override - public Object2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2CharMaps @Override public char putAndMoveToLast(T key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(T key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(T key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Object2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet> object2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2DoubleMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2DoubleMaps.java index 917e2e9..ad7a0b4 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2DoubleMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -449,6 +450,10 @@ public class Object2DoubleMaps @Override public double putAndMoveToLast(T key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(T key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(T key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Object2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2DoubleOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet> object2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2DoubleEntrySet()); @@ -630,15 +647,17 @@ public class Object2DoubleMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2DoubleMap.Entry first() { return set.first(); } + public Object2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2DoubleMap.Entry last() { return set.last(); } + public Object2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Object2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2DoubleMaps @Override public double putAndMoveToLast(T key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(T key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(T key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Object2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet> object2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2FloatMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2FloatMaps.java index 9ef8caf..0156c2e 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2FloatMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2FloatMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -449,6 +450,10 @@ public class Object2FloatMaps @Override public float putAndMoveToLast(T key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(T key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(T key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Object2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2FloatOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet> object2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2FloatEntrySet()); @@ -630,15 +647,17 @@ public class Object2FloatMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2FloatMap.Entry first() { return set.first(); } + public Object2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2FloatMap.Entry last() { return set.last(); } + public Object2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Object2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2FloatMaps @Override public float putAndMoveToLast(T key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(T key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(T key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Object2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet> object2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2IntMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2IntMaps.java index a1a6d81..ffdd514 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2IntMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2IntMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -449,6 +450,10 @@ public class Object2IntMaps @Override public int putAndMoveToLast(T key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(T key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(T key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Object2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2IntOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet> object2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2IntEntrySet()); @@ -630,15 +647,17 @@ public class Object2IntMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2IntMap.Entry first() { return set.first(); } + public Object2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2IntMap.Entry last() { return set.last(); } + public Object2IntMap.Entry getLast() { return set.getLast(); } @Override - public Object2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2IntMaps @Override public int putAndMoveToLast(T key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(T key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(T key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Object2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet> object2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2LongMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2LongMaps.java index 8b13db2..6010ce4 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2LongMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2LongMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -449,6 +450,10 @@ public class Object2LongMaps @Override public long putAndMoveToLast(T key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(T key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(T key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Object2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2LongOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet> object2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2LongEntrySet()); @@ -630,15 +647,17 @@ public class Object2LongMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2LongMap.Entry first() { return set.first(); } + public Object2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2LongMap.Entry last() { return set.last(); } + public Object2LongMap.Entry getLast() { return set.getLast(); } @Override - public Object2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2LongMaps @Override public long putAndMoveToLast(T key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(T key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(T key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Object2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet> object2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ObjectMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ObjectMaps.java index 55647be..7faff62 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ObjectMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -440,6 +441,10 @@ public class Object2ObjectMaps @Override public V putAndMoveToLast(T key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(T key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(T key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -460,13 +465,25 @@ public class Object2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Object2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2ObjectOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Object2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2ObjectMap.Entry first() { return set.first(); } + public Object2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ObjectMap.Entry last() { return set.last(); } + public Object2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Object2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -741,6 +760,10 @@ public class Object2ObjectMaps @Override public V putAndMoveToLast(T key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(T key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(T key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -761,13 +784,25 @@ public class Object2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Object2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ShortMaps.java b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ShortMaps.java index 2e90b19..cfc7517 100644 --- a/src/main/java/speiger/src/collections/objects/utils/maps/Object2ShortMaps.java +++ b/src/main/java/speiger/src/collections/objects/utils/maps/Object2ShortMaps.java @@ -23,6 +23,7 @@ import speiger.src.collections.objects.sets.ObjectNavigableSet; import speiger.src.collections.objects.sets.ObjectSortedSet; import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -449,6 +450,10 @@ public class Object2ShortMaps @Override public short putAndMoveToLast(T key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(T key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(T key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(T key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(T key) { throw new UnsupportedOperationException(); } @@ -469,13 +474,25 @@ public class Object2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Object2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Object2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Object2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Object2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Object2ShortOrderedMap copy() { return map.copy(); } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.unmodifiable(map.keySet()); return (ObjectOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.object2ShortEntrySet()); @@ -630,15 +647,17 @@ public class Object2ShortMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Object2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Object2ShortMap.Entry first() { return set.first(); } + public Object2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Object2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Object2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Object2ShortMap.Entry last() { return set.last(); } + public Object2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Object2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Object2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -760,6 +779,10 @@ public class Object2ShortMaps @Override public short putAndMoveToLast(T key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(T key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(T key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(T key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(T key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -780,13 +803,25 @@ public class Object2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Object2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Object2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Object2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Object2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Object2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ObjectOrderedSet keySet() { if(keys == null) keys = ObjectSets.synchronize(map.keySet(), mutex); return (ObjectOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet> object2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.object2ShortEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/collections/AbstractShortCollection.java b/src/main/java/speiger/src/collections/shorts/collections/AbstractShortCollection.java index 753028a..9145899 100644 --- a/src/main/java/speiger/src/collections/shorts/collections/AbstractShortCollection.java +++ b/src/main/java/speiger/src/collections/shorts/collections/AbstractShortCollection.java @@ -1,9 +1,11 @@ package speiger.src.collections.shorts.collections; import java.util.Collection; +import java.util.function.Supplier; import java.util.Objects; import java.util.AbstractCollection; +import speiger.src.collections.shorts.lists.ShortListIterator; import speiger.src.collections.shorts.functions.ShortConsumer; import speiger.src.collections.shorts.utils.ShortIterators; import speiger.src.collections.shorts.utils.ShortArrays; @@ -249,4 +251,68 @@ public abstract class AbstractShortCollection extends AbstractCollection if (a.length > size()) a[size()] = (short)0; return a; } + + public static class ReverseShortOrderedCollection extends AbstractShortCollection implements ShortOrderedCollection { + ShortOrderedCollection collection; + Supplier reverseIterator; + + public ReverseShortOrderedCollection(ShortOrderedCollection collection, Supplier reverseIterator) { + this.collection = collection; + this.reverseIterator = reverseIterator; + } + + @Override + public boolean add(short o) { return collection.add(o); } + @Override + public ShortOrderedCollection reversed() { return collection; } + @Override + public void addFirst(short e) { collection.addLast(e); } + @Override + public void addLast(short e) { collection.addFirst(e); } + @Override + public boolean contains(short e) { return collection.contains(e); } + @Override + public boolean remShort(short e) { return collection.remShort(e); } + @Override + public void clear() { collection.clear(); } + @Override + public short getFirstShort() { return collection.getLastShort(); } + @Override + public short removeFirstShort() { return collection.removeLastShort(); } + @Override + public short getLastShort() { return collection.getFirstShort(); } + @Override + public short removeLastShort() { return collection.removeFirstShort(); } + @Override + public ShortIterator iterator() { return reverseIterator.get(); } + @Override + public int size() { return collection.size(); } + } + + public static class ReverseBiIterator implements ShortListIterator { + ShortListIterator it; + + public ReverseBiIterator(ShortListIterator it) { + this.it = it; + } + + @Override + public short nextShort() { return it.previousShort(); } + @Override + public boolean hasNext() { return it.hasPrevious(); } + @Override + public boolean hasPrevious() { return it.hasNext(); } + @Override + public short previousShort() { return it.nextShort(); } + @Override + public void remove() { it.remove(); } + @Override + public int nextIndex() { return it.previousIndex(); } + @Override + public int previousIndex() { return it.nextIndex(); } + @Override + public void set(short e) { it.set(e); } + @Override + public void add(short e) { it.add(e); } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/shorts/collections/ShortBidirectionalIterator.java b/src/main/java/speiger/src/collections/shorts/collections/ShortBidirectionalIterator.java index f8e9cbc..dd4640e 100644 --- a/src/main/java/speiger/src/collections/shorts/collections/ShortBidirectionalIterator.java +++ b/src/main/java/speiger/src/collections/shorts/collections/ShortBidirectionalIterator.java @@ -1,10 +1,10 @@ package speiger.src.collections.shorts.collections; -import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; /** - * A Type-Specific {@link ObjectBidirectionalIterator} to reduce (un)boxing + * This is a basically a {@link java.util.ListIterator} without the index functions. + * Allowing to have a simple Bidirectional Iterator without having to keep track of the Iteration index. */ -public interface ShortBidirectionalIterator extends ShortIterator, ObjectBidirectionalIterator +public interface ShortBidirectionalIterator extends ShortIterator { /** * Returns true if the Iterator has a Previous element @@ -19,11 +19,11 @@ public interface ShortBidirectionalIterator extends ShortIterator, ObjectBidirec */ public short previousShort(); - /** {@inheritDoc} + /** *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. + * @return the Previous element of the iterator.+ */ - @Override @Deprecated public default Short previous() { return Short.valueOf(previousShort()); diff --git a/src/main/java/speiger/src/collections/shorts/collections/ShortOrderedCollection.java b/src/main/java/speiger/src/collections/shorts/collections/ShortOrderedCollection.java new file mode 100644 index 0000000..acd7780 --- /dev/null +++ b/src/main/java/speiger/src/collections/shorts/collections/ShortOrderedCollection.java @@ -0,0 +1,40 @@ +package speiger.src.collections.shorts.collections; + +public interface ShortOrderedCollection extends ShortCollection { + + ShortOrderedCollection 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(short 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(short e); + + /** + * A method to get the first element in the collection + * @return first element in the collection + */ + public short getFirstShort(); + /** + * A method to get and remove the first element in the collection + * @return first element in the collection + */ + public short removeFirstShort(); + /** + * A method to get the last element in the collection + * @return last element in the collection + */ + public short getLastShort(); + /** + * A method to get and remove the last element in the collection + * @return last element in the collection + */ + public short removeLastShort(); + +} \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/shorts/lists/AbstractShortList.java b/src/main/java/speiger/src/collections/shorts/lists/AbstractShortList.java index bed164c..57896e3 100644 --- a/src/main/java/speiger/src/collections/shorts/lists/AbstractShortList.java +++ b/src/main/java/speiger/src/collections/shorts/lists/AbstractShortList.java @@ -466,7 +466,6 @@ public abstract class AbstractShortList extends AbstractShortCollection implemen public int size() { return size; } - @Override public ShortSplititerator spliterator() { return ShortSplititerators.createSplititerator(this, 16464); } diff --git a/src/main/java/speiger/src/collections/shorts/lists/ShortLinkedList.java b/src/main/java/speiger/src/collections/shorts/lists/ShortLinkedList.java index fa7d1b9..0223476 100644 --- a/src/main/java/speiger/src/collections/shorts/lists/ShortLinkedList.java +++ b/src/main/java/speiger/src/collections/shorts/lists/ShortLinkedList.java @@ -24,8 +24,7 @@ import speiger.src.collections.shorts.functions.ShortConsumer; import speiger.src.collections.shorts.utils.ShortArrays; import speiger.src.collections.objects.utils.ObjectArrays; import java.util.stream.IntStream; -import java.util.stream.StreamSupport; -import speiger.src.collections.shorts.collections.ShortSplititerator; +import java.util.stream.StreamSupport;import speiger.src.collections.shorts.collections.ShortSplititerator; import speiger.src.collections.shorts.utils.ShortSplititerators; import speiger.src.collections.utils.SanityChecks; @@ -361,7 +360,7 @@ public class ShortLinkedList extends AbstractShortList implements ShortPriorityD if(index == 0) return new ListIter(first, index); return new ListIter(getNode(index), index); } - + /** * Returns a Java-Type-Specific Stream to reduce boxing/unboxing. * @return a Stream of the closest java type @@ -372,8 +371,7 @@ public class ShortLinkedList extends AbstractShortList implements ShortPriorityD * Returns a Java-Type-Specific Parallel Stream to reduce boxing/unboxing. * @return a Stream of the closest java type */ - public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } - /** + public IntStream parallelPrimitiveStream() { return StreamSupport.intStream(new SplitIterator(this, first, 0), true); } /** * A Type Specific Type Splititerator to reduce boxing/unboxing * @return type specific splititerator */ diff --git a/src/main/java/speiger/src/collections/shorts/lists/ShortList.java b/src/main/java/speiger/src/collections/shorts/lists/ShortList.java index ffc782c..6956132 100644 --- a/src/main/java/speiger/src/collections/shorts/lists/ShortList.java +++ b/src/main/java/speiger/src/collections/shorts/lists/ShortList.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.function.UnaryOperator; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortSplititerator; import speiger.src.collections.ints.functions.consumer.IntShortConsumer; import speiger.src.collections.shorts.functions.ShortComparator; @@ -21,7 +22,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 */ -public interface ShortList extends ShortCollection, List +public interface ShortList extends ShortOrderedCollection, List { /** * A Type-Specific add Function to reduce (un)boxing @@ -84,6 +85,24 @@ public interface ShortList extends ShortCollection, List */ public boolean addAll(int index, ShortList 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(short 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(short e) { + add(e); + } + /** * 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. @@ -414,9 +433,9 @@ public interface ShortList extends ShortCollection, List @Override @Deprecated public default boolean add(Short e) { - return ShortCollection.super.add(e); + return ShortOrderedCollection.super.add(e); } - + /** {@inheritDoc} *

This default implementation delegates to the corresponding type-specific function. * @deprecated Please use the corresponding type-specific function instead. @@ -464,7 +483,7 @@ public interface ShortList extends ShortCollection, List @Override @Deprecated public default boolean contains(Object o) { - return ShortCollection.super.contains(o); + return ShortOrderedCollection.super.contains(o); } /** {@inheritDoc} @@ -474,7 +493,7 @@ public interface ShortList extends ShortCollection, List @Override @Deprecated public default boolean remove(Object o) { - return ShortCollection.super.remove(o); + return ShortOrderedCollection.super.remove(o); } /** {@inheritDoc} diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2BooleanMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2BooleanMap.java index a986333..fe8d113 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2BooleanMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2BooleanMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortBooleanConsumer; import speiger.src.collections.shorts.functions.function.ShortPredicate; import speiger.src.collections.shorts.functions.function.ShortBooleanUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2BooleanMap; +import speiger.src.collections.shorts.maps.interfaces.Short2BooleanOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2BooleanMaps; @@ -85,7 +90,7 @@ public abstract class AbstractShort2BooleanMap extends AbstractMap short2BooleanEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2BooleanEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public BooleanOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2BooleanOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ByteMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ByteMap.java index 1bb13e5..daae1e0 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ByteMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ByteMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortByteConsumer; import speiger.src.collections.shorts.functions.function.Short2ByteFunction; import speiger.src.collections.shorts.functions.function.ShortByteUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2ByteMap; +import speiger.src.collections.shorts.maps.interfaces.Short2ByteOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2ByteMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2ByteMap extends AbstractMap implements Short2ByteMap { - protected byte defaultReturnValue = (byte)0; + protected byte defaultReturnValue = (byte)-1; @Override public byte getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2ByteMap extends AbstractMap imp public void putAll(Short[] keys, Byte[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedShort2ByteOrderedMap extends AbstractShort2ByteMap implements Short2ByteOrderedMap { + Short2ByteOrderedMap map; + + public ReversedShort2ByteOrderedMap(Short2ByteOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2ByteMap setDefaultReturnValue(byte v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public byte getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2ByteOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public byte put(short key, byte value) { return map.put(key, value); } + @Override + public byte putIfAbsent(short key, byte value) { return map.putIfAbsent(key, value); } + @Override + public byte addTo(short key, byte value) { return map.addTo(key, value); } + @Override + public byte subFrom(short key, byte value) { return map.subFrom(key, value); } + @Override + public byte remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, byte value) { return map.remove(key, value); } + @Override + public byte removeOrDefault(short key, byte defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(byte value) { return map.containsValue(value); } + @Override + public boolean replace(short key, byte oldValue, byte newValue) { return map.replace(key, oldValue, newValue); } + @Override + public byte replace(short key, byte value) { return map.replace(key, value); } + @Override + public void replaceBytes(Short2ByteMap m) { map.replaceBytes(m); } + @Override + public void replaceBytes(ShortByteUnaryOperator mappingFunction) { map.replaceBytes(mappingFunction); } + @Override + public byte computeByte(short key, ShortByteUnaryOperator mappingFunction) { return map.computeByte(key, mappingFunction); } + @Override + public byte computeByteIfAbsent(short key, Short2ByteFunction mappingFunction) { return map.computeByteIfAbsent(key, mappingFunction); } + @Override + public byte supplyByteIfAbsent(short key, ByteSupplier valueProvider) { return map.supplyByteIfAbsent(key, valueProvider); } + @Override + public byte computeByteIfPresent(short key, ShortByteUnaryOperator mappingFunction) { return map.computeByteIfPresent(key, mappingFunction); } + @Override + public byte computeByteNonDefault(short key, ShortByteUnaryOperator mappingFunction) { return map.computeByteNonDefault(key, mappingFunction); } + @Override + public byte computeByteIfAbsentNonDefault(short key, Short2ByteFunction mappingFunction) { return map.computeByteIfAbsentNonDefault(key, mappingFunction); } + @Override + public byte supplyByteIfAbsentNonDefault(short key, ByteSupplier valueProvider) { return map.supplyByteIfAbsentNonDefault(key, valueProvider); } + @Override + public byte computeByteIfPresentNonDefault(short key, ShortByteUnaryOperator mappingFunction) { return map.computeByteIfPresentNonDefault(key, mappingFunction); } + @Override + public byte mergeByte(short key, byte value, ByteByteUnaryOperator mappingFunction) { return map.mergeByte(key, value, mappingFunction); } + @Override + public byte getOrDefault(short key, byte defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public byte get(short key) { return map.get(key); } + @Override + public byte putAndMoveToFirst(short key, byte value) { return map.putAndMoveToLast(key, value); } + @Override + public byte putAndMoveToLast(short key, byte value) { return map.putAndMoveToFirst(key, value); } + @Override + public byte putFirst(short key, byte value) { return map.putLast(key, value); } + @Override + public byte putLast(short key, byte value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public byte getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public byte getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public byte firstByteValue() { return map.lastByteValue(); } + @Override + public byte lastByteValue() { return map.firstByteValue(); } + @Override + public Short2ByteMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2ByteMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2ByteMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2ByteMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2ByteEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2ByteEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public ByteOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2ByteOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2CharMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2CharMap.java index 4b3a35a..9375d77 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2CharMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2CharMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortCharConsumer; import speiger.src.collections.shorts.functions.function.Short2CharFunction; import speiger.src.collections.shorts.functions.function.ShortCharUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2CharMap; +import speiger.src.collections.shorts.maps.interfaces.Short2CharOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.chars.collections.CharOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2CharMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2CharMap extends AbstractMap implements Short2CharMap { - protected char defaultReturnValue = (char)0; + protected char defaultReturnValue = (char)-1; @Override public char getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2CharMap extends AbstractMap short2CharEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2CharEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public CharOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2CharOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2DoubleMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2DoubleMap.java index a759bb7..20634ce 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2DoubleMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2DoubleMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortDoubleConsumer; import speiger.src.collections.shorts.functions.function.Short2DoubleFunction; import speiger.src.collections.shorts.functions.function.ShortDoubleUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2DoubleMap; +import speiger.src.collections.shorts.maps.interfaces.Short2DoubleOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2DoubleMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2DoubleMap extends AbstractMap implements Short2DoubleMap { - protected double defaultReturnValue = 0D; + protected double defaultReturnValue = -1D; @Override public double getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2DoubleMap extends AbstractMap public void putAll(Short[] keys, Double[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i return hash; } + public static class ReversedShort2DoubleOrderedMap extends AbstractShort2DoubleMap implements Short2DoubleOrderedMap { + Short2DoubleOrderedMap map; + + public ReversedShort2DoubleOrderedMap(Short2DoubleOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2DoubleMap setDefaultReturnValue(double v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public double getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2DoubleOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public double put(short key, double value) { return map.put(key, value); } + @Override + public double putIfAbsent(short key, double value) { return map.putIfAbsent(key, value); } + @Override + public double addTo(short key, double value) { return map.addTo(key, value); } + @Override + public double subFrom(short key, double value) { return map.subFrom(key, value); } + @Override + public double remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, double value) { return map.remove(key, value); } + @Override + public double removeOrDefault(short key, double defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(double value) { return map.containsValue(value); } + @Override + public boolean replace(short key, double oldValue, double newValue) { return map.replace(key, oldValue, newValue); } + @Override + public double replace(short key, double value) { return map.replace(key, value); } + @Override + public void replaceDoubles(Short2DoubleMap m) { map.replaceDoubles(m); } + @Override + public void replaceDoubles(ShortDoubleUnaryOperator mappingFunction) { map.replaceDoubles(mappingFunction); } + @Override + public double computeDouble(short key, ShortDoubleUnaryOperator mappingFunction) { return map.computeDouble(key, mappingFunction); } + @Override + public double computeDoubleIfAbsent(short key, Short2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsent(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsent(short key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsent(key, valueProvider); } + @Override + public double computeDoubleIfPresent(short key, ShortDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresent(key, mappingFunction); } + @Override + public double computeDoubleNonDefault(short key, ShortDoubleUnaryOperator mappingFunction) { return map.computeDoubleNonDefault(key, mappingFunction); } + @Override + public double computeDoubleIfAbsentNonDefault(short key, Short2DoubleFunction mappingFunction) { return map.computeDoubleIfAbsentNonDefault(key, mappingFunction); } + @Override + public double supplyDoubleIfAbsentNonDefault(short key, DoubleSupplier valueProvider) { return map.supplyDoubleIfAbsentNonDefault(key, valueProvider); } + @Override + public double computeDoubleIfPresentNonDefault(short key, ShortDoubleUnaryOperator mappingFunction) { return map.computeDoubleIfPresentNonDefault(key, mappingFunction); } + @Override + public double mergeDouble(short key, double value, DoubleDoubleUnaryOperator mappingFunction) { return map.mergeDouble(key, value, mappingFunction); } + @Override + public double getOrDefault(short key, double defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public double get(short key) { return map.get(key); } + @Override + public double putAndMoveToFirst(short key, double value) { return map.putAndMoveToLast(key, value); } + @Override + public double putAndMoveToLast(short key, double value) { return map.putAndMoveToFirst(key, value); } + @Override + public double putFirst(short key, double value) { return map.putLast(key, value); } + @Override + public double putLast(short key, double value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public double getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public double getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public double firstDoubleValue() { return map.lastDoubleValue(); } + @Override + public double lastDoubleValue() { return map.firstDoubleValue(); } + @Override + public Short2DoubleMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2DoubleMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2DoubleMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2DoubleMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2DoubleEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2DoubleEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public DoubleOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2DoubleOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2FloatMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2FloatMap.java index 9ae69ba..7a3550e 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2FloatMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2FloatMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortFloatConsumer; import speiger.src.collections.shorts.functions.function.Short2FloatFunction; import speiger.src.collections.shorts.functions.function.ShortFloatUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2FloatMap; +import speiger.src.collections.shorts.maps.interfaces.Short2FloatOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.floats.collections.FloatOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2FloatMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2FloatMap extends AbstractMap implements Short2FloatMap { - protected float defaultReturnValue = 0F; + protected float defaultReturnValue = -1F; @Override public float getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2FloatMap extends AbstractMap i public void putAll(Short[] keys, Float[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedShort2FloatOrderedMap extends AbstractShort2FloatMap implements Short2FloatOrderedMap { + Short2FloatOrderedMap map; + + public ReversedShort2FloatOrderedMap(Short2FloatOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2FloatMap setDefaultReturnValue(float v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public float getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2FloatOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public float put(short key, float value) { return map.put(key, value); } + @Override + public float putIfAbsent(short key, float value) { return map.putIfAbsent(key, value); } + @Override + public float addTo(short key, float value) { return map.addTo(key, value); } + @Override + public float subFrom(short key, float value) { return map.subFrom(key, value); } + @Override + public float remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, float value) { return map.remove(key, value); } + @Override + public float removeOrDefault(short key, float defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(float value) { return map.containsValue(value); } + @Override + public boolean replace(short key, float oldValue, float newValue) { return map.replace(key, oldValue, newValue); } + @Override + public float replace(short key, float value) { return map.replace(key, value); } + @Override + public void replaceFloats(Short2FloatMap m) { map.replaceFloats(m); } + @Override + public void replaceFloats(ShortFloatUnaryOperator mappingFunction) { map.replaceFloats(mappingFunction); } + @Override + public float computeFloat(short key, ShortFloatUnaryOperator mappingFunction) { return map.computeFloat(key, mappingFunction); } + @Override + public float computeFloatIfAbsent(short key, Short2FloatFunction mappingFunction) { return map.computeFloatIfAbsent(key, mappingFunction); } + @Override + public float supplyFloatIfAbsent(short key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsent(key, valueProvider); } + @Override + public float computeFloatIfPresent(short key, ShortFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresent(key, mappingFunction); } + @Override + public float computeFloatNonDefault(short key, ShortFloatUnaryOperator mappingFunction) { return map.computeFloatNonDefault(key, mappingFunction); } + @Override + public float computeFloatIfAbsentNonDefault(short key, Short2FloatFunction mappingFunction) { return map.computeFloatIfAbsentNonDefault(key, mappingFunction); } + @Override + public float supplyFloatIfAbsentNonDefault(short key, FloatSupplier valueProvider) { return map.supplyFloatIfAbsentNonDefault(key, valueProvider); } + @Override + public float computeFloatIfPresentNonDefault(short key, ShortFloatUnaryOperator mappingFunction) { return map.computeFloatIfPresentNonDefault(key, mappingFunction); } + @Override + public float mergeFloat(short key, float value, FloatFloatUnaryOperator mappingFunction) { return map.mergeFloat(key, value, mappingFunction); } + @Override + public float getOrDefault(short key, float defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public float get(short key) { return map.get(key); } + @Override + public float putAndMoveToFirst(short key, float value) { return map.putAndMoveToLast(key, value); } + @Override + public float putAndMoveToLast(short key, float value) { return map.putAndMoveToFirst(key, value); } + @Override + public float putFirst(short key, float value) { return map.putLast(key, value); } + @Override + public float putLast(short key, float value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public float getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public float getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public float firstFloatValue() { return map.lastFloatValue(); } + @Override + public float lastFloatValue() { return map.firstFloatValue(); } + @Override + public Short2FloatMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2FloatMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2FloatMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2FloatMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2FloatEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2FloatEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public FloatOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2FloatOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2IntMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2IntMap.java index 7275dff..c5575ed 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2IntMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2IntMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortIntConsumer; import speiger.src.collections.shorts.functions.function.Short2IntFunction; import speiger.src.collections.shorts.functions.function.ShortIntUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2IntMap; +import speiger.src.collections.shorts.maps.interfaces.Short2IntOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.ints.collections.IntOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2IntMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2IntMap extends AbstractMap implements Short2IntMap { - protected int defaultReturnValue = 0; + protected int defaultReturnValue = -1; @Override public int getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2IntMap extends AbstractMap i public void putAll(Short[] keys, Integer[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedShort2IntOrderedMap extends AbstractShort2IntMap implements Short2IntOrderedMap { + Short2IntOrderedMap map; + + public ReversedShort2IntOrderedMap(Short2IntOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2IntMap setDefaultReturnValue(int v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public int getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2IntOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public int put(short key, int value) { return map.put(key, value); } + @Override + public int putIfAbsent(short key, int value) { return map.putIfAbsent(key, value); } + @Override + public int addTo(short key, int value) { return map.addTo(key, value); } + @Override + public int subFrom(short key, int value) { return map.subFrom(key, value); } + @Override + public int remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, int value) { return map.remove(key, value); } + @Override + public int removeOrDefault(short key, int defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(int value) { return map.containsValue(value); } + @Override + public boolean replace(short key, int oldValue, int newValue) { return map.replace(key, oldValue, newValue); } + @Override + public int replace(short key, int value) { return map.replace(key, value); } + @Override + public void replaceInts(Short2IntMap m) { map.replaceInts(m); } + @Override + public void replaceInts(ShortIntUnaryOperator mappingFunction) { map.replaceInts(mappingFunction); } + @Override + public int computeInt(short key, ShortIntUnaryOperator mappingFunction) { return map.computeInt(key, mappingFunction); } + @Override + public int computeIntIfAbsent(short key, Short2IntFunction mappingFunction) { return map.computeIntIfAbsent(key, mappingFunction); } + @Override + public int supplyIntIfAbsent(short key, IntSupplier valueProvider) { return map.supplyIntIfAbsent(key, valueProvider); } + @Override + public int computeIntIfPresent(short key, ShortIntUnaryOperator mappingFunction) { return map.computeIntIfPresent(key, mappingFunction); } + @Override + public int computeIntNonDefault(short key, ShortIntUnaryOperator mappingFunction) { return map.computeIntNonDefault(key, mappingFunction); } + @Override + public int computeIntIfAbsentNonDefault(short key, Short2IntFunction mappingFunction) { return map.computeIntIfAbsentNonDefault(key, mappingFunction); } + @Override + public int supplyIntIfAbsentNonDefault(short key, IntSupplier valueProvider) { return map.supplyIntIfAbsentNonDefault(key, valueProvider); } + @Override + public int computeIntIfPresentNonDefault(short key, ShortIntUnaryOperator mappingFunction) { return map.computeIntIfPresentNonDefault(key, mappingFunction); } + @Override + public int mergeInt(short key, int value, IntIntUnaryOperator mappingFunction) { return map.mergeInt(key, value, mappingFunction); } + @Override + public int getOrDefault(short key, int defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public int get(short key) { return map.get(key); } + @Override + public int putAndMoveToFirst(short key, int value) { return map.putAndMoveToLast(key, value); } + @Override + public int putAndMoveToLast(short key, int value) { return map.putAndMoveToFirst(key, value); } + @Override + public int putFirst(short key, int value) { return map.putLast(key, value); } + @Override + public int putLast(short key, int value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public int getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public int getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public int firstIntValue() { return map.lastIntValue(); } + @Override + public int lastIntValue() { return map.firstIntValue(); } + @Override + public Short2IntMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2IntMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2IntMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2IntMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2IntEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2IntEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public IntOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2IntOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2LongMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2LongMap.java index c2c1763..e94db12 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2LongMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2LongMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortLongConsumer; import speiger.src.collections.shorts.functions.function.Short2LongFunction; import speiger.src.collections.shorts.functions.function.ShortLongUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2LongMap; +import speiger.src.collections.shorts.maps.interfaces.Short2LongOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.longs.collections.LongOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2LongMaps; @@ -27,7 +32,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2LongMap extends AbstractMap implements Short2LongMap { - protected long defaultReturnValue = 0L; + protected long defaultReturnValue = -1L; @Override public long getDefaultReturnValue() { @@ -91,7 +96,7 @@ public abstract class AbstractShort2LongMap extends AbstractMap imp public void putAll(Short[] keys, Long[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i imp return hash; } + public static class ReversedShort2LongOrderedMap extends AbstractShort2LongMap implements Short2LongOrderedMap { + Short2LongOrderedMap map; + + public ReversedShort2LongOrderedMap(Short2LongOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2LongMap setDefaultReturnValue(long v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public long getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2LongOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public long put(short key, long value) { return map.put(key, value); } + @Override + public long putIfAbsent(short key, long value) { return map.putIfAbsent(key, value); } + @Override + public long addTo(short key, long value) { return map.addTo(key, value); } + @Override + public long subFrom(short key, long value) { return map.subFrom(key, value); } + @Override + public long remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, long value) { return map.remove(key, value); } + @Override + public long removeOrDefault(short key, long defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(long value) { return map.containsValue(value); } + @Override + public boolean replace(short key, long oldValue, long newValue) { return map.replace(key, oldValue, newValue); } + @Override + public long replace(short key, long value) { return map.replace(key, value); } + @Override + public void replaceLongs(Short2LongMap m) { map.replaceLongs(m); } + @Override + public void replaceLongs(ShortLongUnaryOperator mappingFunction) { map.replaceLongs(mappingFunction); } + @Override + public long computeLong(short key, ShortLongUnaryOperator mappingFunction) { return map.computeLong(key, mappingFunction); } + @Override + public long computeLongIfAbsent(short key, Short2LongFunction mappingFunction) { return map.computeLongIfAbsent(key, mappingFunction); } + @Override + public long supplyLongIfAbsent(short key, LongSupplier valueProvider) { return map.supplyLongIfAbsent(key, valueProvider); } + @Override + public long computeLongIfPresent(short key, ShortLongUnaryOperator mappingFunction) { return map.computeLongIfPresent(key, mappingFunction); } + @Override + public long computeLongNonDefault(short key, ShortLongUnaryOperator mappingFunction) { return map.computeLongNonDefault(key, mappingFunction); } + @Override + public long computeLongIfAbsentNonDefault(short key, Short2LongFunction mappingFunction) { return map.computeLongIfAbsentNonDefault(key, mappingFunction); } + @Override + public long supplyLongIfAbsentNonDefault(short key, LongSupplier valueProvider) { return map.supplyLongIfAbsentNonDefault(key, valueProvider); } + @Override + public long computeLongIfPresentNonDefault(short key, ShortLongUnaryOperator mappingFunction) { return map.computeLongIfPresentNonDefault(key, mappingFunction); } + @Override + public long mergeLong(short key, long value, LongLongUnaryOperator mappingFunction) { return map.mergeLong(key, value, mappingFunction); } + @Override + public long getOrDefault(short key, long defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public long get(short key) { return map.get(key); } + @Override + public long putAndMoveToFirst(short key, long value) { return map.putAndMoveToLast(key, value); } + @Override + public long putAndMoveToLast(short key, long value) { return map.putAndMoveToFirst(key, value); } + @Override + public long putFirst(short key, long value) { return map.putLast(key, value); } + @Override + public long putLast(short key, long value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public long getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public long getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public long firstLongValue() { return map.lastLongValue(); } + @Override + public long lastLongValue() { return map.firstLongValue(); } + @Override + public Short2LongMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2LongMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2LongMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2LongMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2LongEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2LongEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public LongOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2LongOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ObjectMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ObjectMap.java index 58433af..79e8d4d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ObjectMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ObjectMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortObjectConsumer; import speiger.src.collections.shorts.functions.function.ShortFunction; import speiger.src.collections.shorts.functions.function.ShortObjectUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2ObjectMap; +import speiger.src.collections.shorts.maps.interfaces.Short2ObjectOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2ObjectMaps; @@ -85,7 +90,7 @@ public abstract class AbstractShort2ObjectMap extends AbstractMap i public void putAll(Short[] keys, V[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i extends AbstractMap i return hash; } + public static class ReversedShort2ObjectOrderedMap extends AbstractShort2ObjectMap implements Short2ObjectOrderedMap { + Short2ObjectOrderedMap map; + + public ReversedShort2ObjectOrderedMap(Short2ObjectOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2ObjectMap setDefaultReturnValue(V v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public V getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2ObjectOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public V put(short key, V value) { return map.put(key, value); } + @Override + public V putIfAbsent(short key, V value) { return map.putIfAbsent(key, value); } + @Override + public V remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, V value) { return map.remove(key, value); } + @Override + public V removeOrDefault(short key, V defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(Object value) { return map.containsValue(value); } + @Override + public boolean replace(short key, V oldValue, V newValue) { return map.replace(key, oldValue, newValue); } + @Override + public V replace(short key, V value) { return map.replace(key, value); } + @Override + public void replaceObjects(Short2ObjectMap m) { map.replaceObjects(m); } + @Override + public void replaceObjects(ShortObjectUnaryOperator mappingFunction) { map.replaceObjects(mappingFunction); } + @Override + public V compute(short key, ShortObjectUnaryOperator mappingFunction) { return map.compute(key, mappingFunction); } + @Override + public V computeIfAbsent(short key, ShortFunction mappingFunction) { return map.computeIfAbsent(key, mappingFunction); } + @Override + public V supplyIfAbsent(short key, ObjectSupplier valueProvider) { return map.supplyIfAbsent(key, valueProvider); } + @Override + public V computeIfPresent(short key, ShortObjectUnaryOperator mappingFunction) { return map.computeIfPresent(key, mappingFunction); } + @Override + public V merge(short key, V value, ObjectObjectUnaryOperator mappingFunction) { return map.merge(key, value, mappingFunction); } + @Override + public V getOrDefault(short key, V defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public V get(short key) { return map.get(key); } + @Override + public V putAndMoveToFirst(short key, V value) { return map.putAndMoveToLast(key, value); } + @Override + public V putAndMoveToLast(short key, V value) { return map.putAndMoveToFirst(key, value); } + @Override + public V putFirst(short key, V value) { return map.putLast(key, value); } + @Override + public V putLast(short key, V value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public V getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public V getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public V firstValue() { return map.lastValue(); } + @Override + public V lastValue() { return map.firstValue(); } + @Override + public Short2ObjectMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2ObjectMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2ObjectMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2ObjectMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet> short2ObjectEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2ObjectEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public ObjectOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2ObjectOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing * @param the keyType of elements maintained by this Collection diff --git a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ShortMap.java b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ShortMap.java index 100732c..ac61283 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ShortMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/abstracts/AbstractShort2ShortMap.java @@ -9,6 +9,11 @@ import speiger.src.collections.shorts.functions.consumer.ShortShortConsumer; import speiger.src.collections.shorts.functions.function.ShortUnaryOperator; import speiger.src.collections.shorts.functions.function.ShortShortUnaryOperator; import speiger.src.collections.shorts.maps.interfaces.Short2ShortMap; +import speiger.src.collections.shorts.maps.interfaces.Short2ShortOrderedMap; +import speiger.src.collections.shorts.sets.ShortOrderedSet; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; +import speiger.src.collections.objects.sets.AbstractObjectSet; +import speiger.src.collections.objects.sets.ObjectOrderedSet; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.maps.Short2ShortMaps; @@ -25,7 +30,7 @@ import speiger.src.collections.utils.SanityChecks; */ public abstract class AbstractShort2ShortMap extends AbstractMap implements Short2ShortMap { - protected short defaultReturnValue = (short)0; + protected short defaultReturnValue = (short)-1; @Override public short getDefaultReturnValue() { @@ -89,7 +94,7 @@ public abstract class AbstractShort2ShortMap extends AbstractMap i public void putAll(Short[] keys, Short[] values, int offset, int size) { SanityChecks.checkArrayCapacity(keys.length, offset, size); SanityChecks.checkArrayCapacity(values.length, offset, size); - for(int i = 0;i i return hash; } + public static class ReversedShort2ShortOrderedMap extends AbstractShort2ShortMap implements Short2ShortOrderedMap { + Short2ShortOrderedMap map; + + public ReversedShort2ShortOrderedMap(Short2ShortOrderedMap map) { + this.map = map; + } + @Override + public AbstractShort2ShortMap setDefaultReturnValue(short v) { + map.setDefaultReturnValue(v); + return this; + } + @Override + public short getDefaultReturnValue() { return map.getDefaultReturnValue(); } + @Override + public Short2ShortOrderedMap copy() { throw new UnsupportedOperationException(); } + @Override + public short put(short key, short value) { return map.put(key, value); } + @Override + public short putIfAbsent(short key, short value) { return map.putIfAbsent(key, value); } + @Override + public short addTo(short key, short value) { return map.addTo(key, value); } + @Override + public short subFrom(short key, short value) { return map.subFrom(key, value); } + @Override + public short remove(short key) { return map.remove(key); } + @Override + public boolean remove(short key, short value) { return map.remove(key, value); } + @Override + public short removeOrDefault(short key, short defaultValue) { return map.removeOrDefault(key, defaultValue); } + @Override + public boolean containsKey(short key) { return map.containsKey(key); } + @Override + public boolean containsValue(short value) { return map.containsValue(value); } + @Override + public boolean replace(short key, short oldValue, short newValue) { return map.replace(key, oldValue, newValue); } + @Override + public short replace(short key, short value) { return map.replace(key, value); } + @Override + public void replaceShorts(Short2ShortMap m) { map.replaceShorts(m); } + @Override + public void replaceShorts(ShortShortUnaryOperator mappingFunction) { map.replaceShorts(mappingFunction); } + @Override + public short computeShort(short key, ShortShortUnaryOperator mappingFunction) { return map.computeShort(key, mappingFunction); } + @Override + public short computeShortIfAbsent(short key, ShortUnaryOperator mappingFunction) { return map.computeShortIfAbsent(key, mappingFunction); } + @Override + public short supplyShortIfAbsent(short key, ShortSupplier valueProvider) { return map.supplyShortIfAbsent(key, valueProvider); } + @Override + public short computeShortIfPresent(short key, ShortShortUnaryOperator mappingFunction) { return map.computeShortIfPresent(key, mappingFunction); } + @Override + public short computeShortNonDefault(short key, ShortShortUnaryOperator mappingFunction) { return map.computeShortNonDefault(key, mappingFunction); } + @Override + public short computeShortIfAbsentNonDefault(short key, ShortUnaryOperator mappingFunction) { return map.computeShortIfAbsentNonDefault(key, mappingFunction); } + @Override + public short supplyShortIfAbsentNonDefault(short key, ShortSupplier valueProvider) { return map.supplyShortIfAbsentNonDefault(key, valueProvider); } + @Override + public short computeShortIfPresentNonDefault(short key, ShortShortUnaryOperator mappingFunction) { return map.computeShortIfPresentNonDefault(key, mappingFunction); } + @Override + public short mergeShort(short key, short value, ShortShortUnaryOperator mappingFunction) { return map.mergeShort(key, value, mappingFunction); } + @Override + public short getOrDefault(short key, short defaultValue) { return map.getOrDefault(key, defaultValue); } + @Override + public short get(short key) { return map.get(key); } + @Override + public short putAndMoveToFirst(short key, short value) { return map.putAndMoveToLast(key, value); } + @Override + public short putAndMoveToLast(short key, short value) { return map.putAndMoveToFirst(key, value); } + @Override + public short putFirst(short key, short value) { return map.putLast(key, value); } + @Override + public short putLast(short key, short value) { return map.putFirst(key, value); } + @Override + public boolean moveToFirst(short key) { return map.moveToLast(key); } + @Override + public boolean moveToLast(short key) { return map.moveToFirst(key); } + @Override + public short getAndMoveToFirst(short key) { return map.getAndMoveToLast(key); } + @Override + public short getAndMoveToLast(short key) { return map.getAndMoveToFirst(key); } + @Override + public short firstShortKey() { return map.lastShortKey(); } + @Override + public short pollFirstShortKey() { return map.pollLastShortKey(); } + @Override + public short lastShortKey() { return map.firstShortKey(); } + @Override + public short pollLastShortKey() { return map.pollFirstShortKey(); } + @Override + public short firstShortValue() { return map.lastShortValue(); } + @Override + public short lastShortValue() { return map.firstShortValue(); } + @Override + public Short2ShortMap.Entry firstEntry() { return map.lastEntry(); } + @Override + public Short2ShortMap.Entry lastEntry() { return map.firstEntry(); } + @Override + public Short2ShortMap.Entry pollFirstEntry() { return map.pollLastEntry(); } + @Override + public Short2ShortMap.Entry pollLastEntry() { return map.pollFirstEntry(); } + @Override + public ObjectOrderedSet short2ShortEntrySet() { return new AbstractObjectSet.ReversedObjectOrderedSet<>(map.short2ShortEntrySet()); } + @Override + public ShortOrderedSet keySet() { return new AbstractShortSet.ReversedShortOrderedSet(map.keySet()); } + @Override + public ShortOrderedCollection values() { return map.values().reversed(); } + @Override + public Short2ShortOrderedMap reversed() { return map; } + } + + /** * A Simple Type Specific Entry class to reduce boxing/unboxing */ diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2BooleanLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2BooleanLinkedOpenCustomHashMap.java index 0720cde..bcdb92d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2BooleanLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2BooleanLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -258,6 +258,54 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto return getDefaultReturnValue(); } + @Override + public boolean putFirst(short key, boolean value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 boolean putLast(short key, boolean value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto return values[lastIndex]; } + @Override + public Short2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } @Override - public Short2BooleanMap.Entry first() { + public Short2BooleanMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstBooleanValue()); } @Override - public Short2BooleanMap.Entry last() { + public Short2BooleanMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastBooleanValue()); } @Override - public Short2BooleanMap.Entry pollFirst() { + public Short2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstBooleanValue()); pollFirstShortKey(); return entry; } @Override - public Short2BooleanMap.Entry pollLast() { + public Short2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastBooleanValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); + public boolean contains(boolean e) { return containsValue(e); } + @Override + public boolean add(boolean o) { throw new UnsupportedOperationException(); } + @Override + public BooleanIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2BooleanLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2BooleanLinkedOpenCustomHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstShortKey(); + return result; } - @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public boolean getLastBoolean() { return lastBooleanValue(); } @Override - public int size() { - return Short2BooleanLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2BooleanLinkedOpenCustomHashMap.this.clear(); + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1284,16 +1399,20 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2BooleanLinkedOpenCustomHashMap extends Short2BooleanOpenCusto public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ByteLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ByteLinkedOpenCustomHashMap.java index 3db4c7b..55080df 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ByteLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ByteLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -258,6 +258,54 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM return getDefaultReturnValue(); } + @Override + public byte putFirst(short key, byte value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 byte putLast(short key, byte value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM return values[lastIndex]; } + @Override + public Short2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } @Override - public Short2ByteMap.Entry first() { + public Short2ByteMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstByteValue()); } @Override - public Short2ByteMap.Entry last() { + public Short2ByteMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastByteValue()); } @Override - public Short2ByteMap.Entry pollFirst() { + public Short2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstByteValue()); pollFirstShortKey(); return entry; } @Override - public Short2ByteMap.Entry pollLast() { + public Short2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastByteValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); + public boolean contains(byte e) { return containsValue(e); } + @Override + public boolean add(byte o) { throw new UnsupportedOperationException(); } + @Override + public ByteIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2ByteLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2ByteLinkedOpenCustomHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstShortKey(); + return result; } - @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public byte getLastByte() { return lastByteValue(); } @Override - public int size() { - return Short2ByteLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2ByteLinkedOpenCustomHashMap.this.clear(); + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1284,16 +1399,20 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2ByteLinkedOpenCustomHashMap extends Short2ByteOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2CharLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2CharLinkedOpenCustomHashMap.java index cc3bd02..ccd92e0 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2CharLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2CharLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -258,6 +258,54 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM return getDefaultReturnValue(); } + @Override + public char putFirst(short key, char value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 char putLast(short key, char value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM return values[lastIndex]; } + @Override + public Short2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } @Override - public Short2CharMap.Entry first() { + public Short2CharMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstCharValue()); } @Override - public Short2CharMap.Entry last() { + public Short2CharMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastCharValue()); } @Override - public Short2CharMap.Entry pollFirst() { + public Short2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstCharValue()); pollFirstShortKey(); return entry; } @Override - public Short2CharMap.Entry pollLast() { + public Short2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastCharValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); + public boolean contains(char e) { return containsValue(e); } + @Override + public boolean add(char o) { throw new UnsupportedOperationException(); } + @Override + public CharIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2CharLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2CharLinkedOpenCustomHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstShortKey(); + return result; } - @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public char getLastChar() { return lastCharValue(); } @Override - public int size() { - return Short2CharLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2CharLinkedOpenCustomHashMap.this.clear(); + public char removeLastChar() { + char result = lastCharValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1284,16 +1399,20 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2CharLinkedOpenCustomHashMap extends Short2CharOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2DoubleLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2DoubleLinkedOpenCustomHashMap.java index ed028c3..0cb6b2d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2DoubleLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2DoubleLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -258,6 +258,54 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH return getDefaultReturnValue(); } + @Override + public double putFirst(short key, double value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 double putLast(short key, double value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH return values[lastIndex]; } + @Override + public Short2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } @Override - public Short2DoubleMap.Entry first() { + public Short2DoubleMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstDoubleValue()); } @Override - public Short2DoubleMap.Entry last() { + public Short2DoubleMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastDoubleValue()); } @Override - public Short2DoubleMap.Entry pollFirst() { + public Short2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstDoubleValue()); pollFirstShortKey(); return entry; } @Override - public Short2DoubleMap.Entry pollLast() { + public Short2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastDoubleValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); + public boolean contains(double e) { return containsValue(e); } + @Override + public boolean add(double o) { throw new UnsupportedOperationException(); } + @Override + public DoubleIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2DoubleLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2DoubleLinkedOpenCustomHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstShortKey(); + return result; } - @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public double getLastDouble() { return lastDoubleValue(); } @Override - public int size() { - return Short2DoubleLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2DoubleLinkedOpenCustomHashMap.this.clear(); + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1284,16 +1399,20 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2DoubleLinkedOpenCustomHashMap extends Short2DoubleOpenCustomH public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2FloatLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2FloatLinkedOpenCustomHashMap.java index 3a26ff5..e670006 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2FloatLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2FloatLinkedOpenCustomHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -258,6 +258,54 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas return getDefaultReturnValue(); } + @Override + public float putFirst(short key, float value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 float putLast(short key, float value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas return values[lastIndex]; } + @Override + public Short2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } @Override - public Short2FloatMap.Entry first() { + public Short2FloatMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstFloatValue()); } @Override - public Short2FloatMap.Entry last() { + public Short2FloatMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastFloatValue()); } @Override - public Short2FloatMap.Entry pollFirst() { + public Short2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstFloatValue()); pollFirstShortKey(); return entry; } @Override - public Short2FloatMap.Entry pollLast() { + public Short2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastFloatValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); + public boolean contains(float e) { return containsValue(e); } + @Override + public boolean add(float o) { throw new UnsupportedOperationException(); } + @Override + public FloatIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2FloatLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2FloatLinkedOpenCustomHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstShortKey(); + return result; } - @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public float getLastFloat() { return lastFloatValue(); } @Override - public int size() { - return Short2FloatLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2FloatLinkedOpenCustomHashMap.this.clear(); + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1284,16 +1399,20 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2FloatLinkedOpenCustomHashMap extends Short2FloatOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2IntLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2IntLinkedOpenCustomHashMap.java index 757667a..eb2e79f 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2IntLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2IntLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -258,6 +258,54 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap return getDefaultReturnValue(); } + @Override + public int putFirst(short key, int value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 int putLast(short key, int value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap return values[lastIndex]; } + @Override + public Short2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } @Override - public Short2IntMap.Entry first() { + public Short2IntMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstIntValue()); } @Override - public Short2IntMap.Entry last() { + public Short2IntMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastIntValue()); } @Override - public Short2IntMap.Entry pollFirst() { + public Short2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstIntValue()); pollFirstShortKey(); return entry; } @Override - public Short2IntMap.Entry pollLast() { + public Short2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastIntValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); + public boolean contains(int e) { return containsValue(e); } + @Override + public boolean add(int o) { throw new UnsupportedOperationException(); } + @Override + public IntIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2IntLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2IntLinkedOpenCustomHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstShortKey(); + return result; } - @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public int getLastInt() { return lastIntValue(); } @Override - public int size() { - return Short2IntLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2IntLinkedOpenCustomHashMap.this.clear(); + public int removeLastInt() { + int result = lastIntValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1284,16 +1399,20 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2IntLinkedOpenCustomHashMap extends Short2IntOpenCustomHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2LongLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2LongLinkedOpenCustomHashMap.java index d4cc99c..42dc1b8 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2LongLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2LongLinkedOpenCustomHashMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -258,6 +258,54 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM return getDefaultReturnValue(); } + @Override + public long putFirst(short key, long value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 long putLast(short key, long value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -393,6 +441,52 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM return values[lastIndex]; } + @Override + public Short2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -406,9 +500,9 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -593,24 +687,24 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } @Override - public Short2LongMap.Entry first() { + public Short2LongMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstLongValue()); } @Override - public Short2LongMap.Entry last() { + public Short2LongMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastLongValue()); } @Override - public Short2LongMap.Entry pollFirst() { + public Short2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstLongValue()); pollFirstShortKey(); return entry; } @Override - public Short2LongMap.Entry pollLast() { + public Short2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastLongValue()); pollLastShortKey(); return entry; @@ -618,7 +712,12 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -628,7 +727,7 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -864,7 +963,12 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -886,22 +990,22 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1030,30 +1134,41 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); + public boolean contains(long e) { return containsValue(e); } + @Override + public boolean add(long o) { throw new UnsupportedOperationException(); } + @Override + public LongIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2LongLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2LongLinkedOpenCustomHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstShortKey(); + return result; } - @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public long getLastLong() { return lastLongValue(); } @Override - public int size() { - return Short2LongLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2LongLinkedOpenCustomHashMap.this.clear(); + public long removeLastLong() { + long result = lastLongValue(); + pollLastShortKey(); + return result; } @Override @@ -1184,7 +1299,7 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1211,7 +1326,7 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1241,7 +1356,7 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1263,7 +1378,7 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1284,16 +1399,20 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1321,11 +1440,11 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1385,20 +1504,30 @@ public class Short2LongLinkedOpenCustomHashMap extends Short2LongOpenCustomHashM public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ObjectLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ObjectLinkedOpenCustomHashMap.java index cb5de4d..d081ed7 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ObjectLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ObjectLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -253,6 +253,54 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust return getDefaultReturnValue(); } + @Override + public V putFirst(short key, V value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 V putLast(short key, V value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -388,6 +436,52 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust return values[lastIndex]; } + @Override + public Short2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> short2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -401,9 +495,9 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -588,24 +682,24 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } @Override - public Short2ObjectMap.Entry first() { + public Short2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstShortKey(), firstValue()); } @Override - public Short2ObjectMap.Entry last() { + public Short2ObjectMap.Entry getLast() { return new BasicEntry<>(lastShortKey(), lastValue()); } @Override - public Short2ObjectMap.Entry pollFirst() { + public Short2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstShortKey(), firstValue()); pollFirstShortKey(); return entry; } @Override - public Short2ObjectMap.Entry pollLast() { + public Short2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastShortKey(), lastValue()); pollLastShortKey(); return entry; @@ -613,7 +707,12 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -623,7 +722,7 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,31 +1129,42 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } - + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ObjectLinkedOpenCustomHashMap.this.size(); - } - + public int size() { return Short2ObjectLinkedOpenCustomHashMap.this.size(); } @Override - public void clear() { - Short2ObjectLinkedOpenCustomHashMap.this.clear(); + public void clear() { Short2ObjectLinkedOpenCustomHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstShortKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastShortKey(); + return result; } @Override @@ -1180,7 +1295,7 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1280,16 +1395,20 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1317,11 +1436,11 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1381,20 +1500,30 @@ public class Short2ObjectLinkedOpenCustomHashMap extends Short2ObjectOpenCust public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ShortLinkedOpenCustomHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ShortLinkedOpenCustomHashMap.java index ed23ce9..6245a6d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ShortLinkedOpenCustomHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/customHash/Short2ShortLinkedOpenCustomHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.utils.ShortStrategy; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -251,6 +251,54 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas return getDefaultReturnValue(); } + @Override + public short putFirst(short key, short value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + 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 short putLast(short key, short value) { + if(strategy.equals(key, (short)0)) { + 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], (short)0)) { + if(strategy.equals(keys[pos], key)) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || strategy.equals(firstShortKey(), key)) return false; @@ -386,6 +434,52 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas return values[lastIndex]; } + @Override + public Short2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(strategy.equals(result.getShortKey(), (short)0)) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -399,9 +493,9 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -586,24 +680,24 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } @Override - public Short2ShortMap.Entry first() { + public Short2ShortMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstShortValue()); } @Override - public Short2ShortMap.Entry last() { + public Short2ShortMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastShortValue()); } @Override - public Short2ShortMap.Entry pollFirst() { + public Short2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstShortValue()); pollFirstShortKey(); return entry; } @Override - public Short2ShortMap.Entry pollLast() { + public Short2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastShortValue()); pollLastShortKey(); return entry; @@ -611,7 +705,12 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -621,7 +720,7 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -857,7 +956,12 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -879,22 +983,22 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1023,30 +1127,41 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); + public boolean contains(short e) { return containsValue(e); } + @Override + public boolean add(short o) { throw new UnsupportedOperationException(); } + @Override + public ShortIterator iterator() { return new ValueIterator(true); } + @Override + public int size() { return Short2ShortLinkedOpenCustomHashMap.this.size(); } + @Override + public void clear() { Short2ShortLinkedOpenCustomHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); } - @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstShortKey(); + return result; } - @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public short getLastShort() { return lastShortValue(); } @Override - public int size() { - return Short2ShortLinkedOpenCustomHashMap.this.size(); - } - - @Override - public void clear() { - Short2ShortLinkedOpenCustomHashMap.this.clear(); + public short removeLastShort() { + short result = lastShortValue(); + pollLastShortKey(); + return result; } @Override @@ -1177,7 +1292,7 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1204,7 +1319,7 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1234,7 +1349,7 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1256,7 +1371,7 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1277,16 +1392,20 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -1314,11 +1433,11 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1378,20 +1497,30 @@ public class Short2ShortLinkedOpenCustomHashMap extends Short2ShortOpenCustomHas public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2BooleanLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2BooleanLinkedOpenHashMap.java index be41a7e..a05824e 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2BooleanLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2BooleanLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2BooleanOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanConsumer; @@ -235,6 +235,54 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp return getDefaultReturnValue(); } + @Override + public boolean putFirst(short key, boolean value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 boolean putLast(short key, boolean value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp return values[lastIndex]; } + @Override + public Short2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = false; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2BooleanEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (BooleanOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } @Override - public Short2BooleanMap.Entry first() { + public Short2BooleanMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstBooleanValue()); } @Override - public Short2BooleanMap.Entry last() { + public Short2BooleanMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastBooleanValue()); } @Override - public Short2BooleanMap.Entry pollFirst() { + public Short2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstBooleanValue()); pollFirstShortKey(); return entry; } @Override - public Short2BooleanMap.Entry pollLast() { + public Short2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastBooleanValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2BooleanLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2BooleanLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2BooleanLinkedOpenHashMap.this.clear(); + public void clear() { Short2BooleanLinkedOpenHashMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstShortKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1279,13 +1394,16 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2BooleanLinkedOpenHashMap extends Short2BooleanOpenHashMap imp public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ByteLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ByteLinkedOpenHashMap.java index a478575..08934a6 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ByteLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ByteLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ByteOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteConsumer; @@ -235,6 +235,54 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement return getDefaultReturnValue(); } + @Override + public byte putFirst(short key, byte value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 byte putLast(short key, byte value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement return values[lastIndex]; } + @Override + public Short2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (byte)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2ByteEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ByteOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } @Override - public Short2ByteMap.Entry first() { + public Short2ByteMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstByteValue()); } @Override - public Short2ByteMap.Entry last() { + public Short2ByteMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastByteValue()); } @Override - public Short2ByteMap.Entry pollFirst() { + public Short2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstByteValue()); pollFirstShortKey(); return entry; } @Override - public Short2ByteMap.Entry pollLast() { + public Short2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastByteValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ByteLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2ByteLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2ByteLinkedOpenHashMap.this.clear(); + public void clear() { Short2ByteLinkedOpenHashMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstShortKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1279,13 +1394,16 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2ByteLinkedOpenHashMap extends Short2ByteOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2CharLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2CharLinkedOpenHashMap.java index 71ae526..3a07f32 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2CharLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2CharLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2CharOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharConsumer; @@ -235,6 +235,54 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement return getDefaultReturnValue(); } + @Override + public char putFirst(short key, char value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 char putLast(short key, char value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement return values[lastIndex]; } + @Override + public Short2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (char)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2CharEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (CharOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } @Override - public Short2CharMap.Entry first() { + public Short2CharMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstCharValue()); } @Override - public Short2CharMap.Entry last() { + public Short2CharMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastCharValue()); } @Override - public Short2CharMap.Entry pollFirst() { + public Short2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstCharValue()); pollFirstShortKey(); return entry; } @Override - public Short2CharMap.Entry pollLast() { + public Short2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastCharValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2CharLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2CharLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2CharLinkedOpenHashMap.this.clear(); + public void clear() { Short2CharLinkedOpenHashMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstShortKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1279,13 +1394,16 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2CharLinkedOpenHashMap extends Short2CharOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2DoubleLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2DoubleLinkedOpenHashMap.java index 2d0ae74..8366677 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2DoubleLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2DoubleLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2DoubleOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleConsumer; @@ -235,6 +235,54 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple return getDefaultReturnValue(); } + @Override + public double putFirst(short key, double value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 double putLast(short key, double value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple return values[lastIndex]; } + @Override + public Short2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0D; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2DoubleEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (DoubleOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } @Override - public Short2DoubleMap.Entry first() { + public Short2DoubleMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstDoubleValue()); } @Override - public Short2DoubleMap.Entry last() { + public Short2DoubleMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastDoubleValue()); } @Override - public Short2DoubleMap.Entry pollFirst() { + public Short2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstDoubleValue()); pollFirstShortKey(); return entry; } @Override - public Short2DoubleMap.Entry pollLast() { + public Short2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastDoubleValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2DoubleLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2DoubleLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2DoubleLinkedOpenHashMap.this.clear(); + public void clear() { Short2DoubleLinkedOpenHashMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstShortKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1279,13 +1394,16 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2DoubleLinkedOpenHashMap extends Short2DoubleOpenHashMap imple public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2FloatLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2FloatLinkedOpenHashMap.java index 05a4136..ba05d9a 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2FloatLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2FloatLinkedOpenHashMap.java @@ -23,7 +23,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2FloatOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatConsumer; @@ -235,6 +235,54 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public float putFirst(short key, float value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 float putLast(short key, float value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme return values[lastIndex]; } + @Override + public Short2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0F; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2FloatEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (FloatOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } @Override - public Short2FloatMap.Entry first() { + public Short2FloatMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstFloatValue()); } @Override - public Short2FloatMap.Entry last() { + public Short2FloatMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastFloatValue()); } @Override - public Short2FloatMap.Entry pollFirst() { + public Short2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstFloatValue()); pollFirstShortKey(); return entry; } @Override - public Short2FloatMap.Entry pollLast() { + public Short2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastFloatValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2FloatLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2FloatLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2FloatLinkedOpenHashMap.this.clear(); + public void clear() { Short2FloatLinkedOpenHashMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstShortKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1279,13 +1394,16 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2FloatLinkedOpenHashMap extends Short2FloatOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2IntLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2IntLinkedOpenHashMap.java index 02ec900..974f07f 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2IntLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2IntLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2IntOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntConsumer; @@ -235,6 +235,54 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements return getDefaultReturnValue(); } + @Override + public int putFirst(short key, int value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 int putLast(short key, int value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements return values[lastIndex]; } + @Override + public Short2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2IntEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (IntOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } @Override - public Short2IntMap.Entry first() { + public Short2IntMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstIntValue()); } @Override - public Short2IntMap.Entry last() { + public Short2IntMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastIntValue()); } @Override - public Short2IntMap.Entry pollFirst() { + public Short2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstIntValue()); pollFirstShortKey(); return entry; } @Override - public Short2IntMap.Entry pollLast() { + public Short2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastIntValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2IntLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2IntLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2IntLinkedOpenHashMap.this.clear(); + public void clear() { Short2IntLinkedOpenHashMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstShortKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1279,13 +1394,16 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2IntLinkedOpenHashMap extends Short2IntOpenHashMap implements public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2LongLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2LongLinkedOpenHashMap.java index 58268c7..051fd55 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2LongLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2LongLinkedOpenHashMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2LongOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongConsumer; @@ -235,6 +235,54 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement return getDefaultReturnValue(); } + @Override + public long putFirst(short key, long value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 long putLast(short key, long value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -391,6 +439,52 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement return values[lastIndex]; } + @Override + public Short2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = 0L; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2LongEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -404,9 +498,9 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (LongOrderedCollection)valuesC; } @Override @@ -591,24 +685,24 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } @Override - public Short2LongMap.Entry first() { + public Short2LongMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstLongValue()); } @Override - public Short2LongMap.Entry last() { + public Short2LongMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastLongValue()); } @Override - public Short2LongMap.Entry pollFirst() { + public Short2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstLongValue()); pollFirstShortKey(); return entry; } @Override - public Short2LongMap.Entry pollLast() { + public Short2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastLongValue()); pollLastShortKey(); return entry; @@ -616,7 +710,12 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -626,7 +725,7 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -859,7 +958,12 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -881,22 +985,22 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1025,32 +1129,43 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2LongLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2LongLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2LongLinkedOpenHashMap.this.clear(); + public void clear() { Short2LongLinkedOpenHashMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstShortKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1180,7 +1295,7 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1207,7 +1322,7 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1237,7 +1352,7 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1259,7 +1374,7 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1279,13 +1394,16 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1316,11 +1434,11 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1380,20 +1498,30 @@ public class Short2LongLinkedOpenHashMap extends Short2LongOpenHashMap implement public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ObjectLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ObjectLinkedOpenHashMap.java index 6d6fd53..7ce1faa 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ObjectLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ObjectLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ObjectOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -230,6 +230,54 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap return getDefaultReturnValue(); } + @Override + public V putFirst(short key, V value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 V putLast(short key, V value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -375,6 +423,52 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap return values[lastIndex]; } + @Override + public Short2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry<>(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = null; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet> short2ObjectEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -388,9 +482,9 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ObjectOrderedCollection)valuesC; } @Override @@ -575,24 +669,24 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } @Override - public Short2ObjectMap.Entry first() { + public Short2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstShortKey(), firstValue()); } @Override - public Short2ObjectMap.Entry last() { + public Short2ObjectMap.Entry getLast() { return new BasicEntry<>(lastShortKey(), lastValue()); } @Override - public Short2ObjectMap.Entry pollFirst() { + public Short2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstShortKey(), firstValue()); pollFirstShortKey(); return entry; } @Override - public Short2ObjectMap.Entry pollLast() { + public Short2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastShortKey(), lastValue()); pollLastShortKey(); return entry; @@ -600,7 +694,12 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -610,7 +709,7 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -843,7 +942,12 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -865,22 +969,22 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1009,33 +1113,44 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ObjectLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2ObjectLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2ObjectLinkedOpenHashMap.this.clear(); + public void clear() { Short2ObjectLinkedOpenHashMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstShortKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1165,7 +1280,7 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1192,7 +1307,7 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1222,7 +1337,7 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1244,7 +1359,7 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1264,13 +1379,16 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1301,11 +1419,11 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1365,20 +1483,30 @@ public class Short2ObjectLinkedOpenHashMap extends Short2ObjectOpenHashMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ShortLinkedOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ShortLinkedOpenHashMap.java index fd0bfa8..2acd083 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ShortLinkedOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/hash/Short2ShortLinkedOpenHashMap.java @@ -22,7 +22,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ShortOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -228,6 +228,54 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme return getDefaultReturnValue(); } + @Override + public short putFirst(short key, short value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToFirstIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(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 short putLast(short key, short value) { + if(key == (short)0) { + if(containsNull) return values[nullIndex]; + values[nullIndex] = value; + containsNull = true; + onNodeAdded(nullIndex); + moveToLastIndex(nullIndex); + } + else { + int pos = HashUtil.mix(Short.hashCode(key)) & mask; + while(key == (short)0) { + if(keys[pos] == key) return values[pos]; + pos = ++pos & mask; + } + keys[pos] = key; + values[pos] = value; + onNodeAdded(pos); + moveToLastIndex(pos); + } + if(size++ >= maxFill) rehash(HashUtil.arraySize(size+1, loadFactor)); + return getDefaultReturnValue(); + } + @Override public boolean moveToFirst(short key) { if(isEmpty() || firstShortKey() == key) return false; @@ -384,6 +432,52 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme return values[lastIndex]; } + @Override + public Short2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = firstIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + + @Override + public Short2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + int pos = lastIndex; + onNodeRemoved(pos); + BasicEntry result = new BasicEntry(keys[pos], values[pos]); + size--; + if(result.getShortKey() == (short)0) { + containsNull = false; + keys[nullIndex] = (short)0; + values[nullIndex] = (short)0; + } + else shiftKeys(pos); + if(nullIndex > minCapacity && size < maxFill / 4 && nullIndex > HashUtil.DEFAULT_MIN_CAPACITY) rehash(nullIndex / 2); + return result; + } + @Override public ObjectOrderedSet short2ShortEntrySet() { if(entrySet == null) entrySet = new MapEntrySet(); @@ -397,9 +491,9 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); - return valuesC; + return (ShortOrderedCollection)valuesC; } @Override @@ -584,24 +678,24 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } @Override - public Short2ShortMap.Entry first() { + public Short2ShortMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstShortValue()); } @Override - public Short2ShortMap.Entry last() { + public Short2ShortMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastShortValue()); } @Override - public Short2ShortMap.Entry pollFirst() { + public Short2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstShortValue()); pollFirstShortKey(); return entry; } @Override - public Short2ShortMap.Entry pollLast() { + public Short2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastShortValue()); pollLastShortKey(); return entry; @@ -609,7 +703,12 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -619,7 +718,7 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -852,7 +951,12 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -874,22 +978,22 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { + public short removeLastShort() { return pollLastShortKey(); } @@ -1018,32 +1122,43 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ShortLinkedOpenHashMap.this.size(); - } - + public int size() { return Short2ShortLinkedOpenHashMap.this.size(); } @Override - public void clear() { - Short2ShortLinkedOpenHashMap.this.clear(); + public void clear() { Short2ShortLinkedOpenHashMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstShortKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1173,7 +1288,7 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1200,7 +1315,7 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry; - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1230,7 +1345,7 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1252,7 +1367,7 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1272,13 +1387,16 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1309,11 +1427,11 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1373,20 +1491,30 @@ public class Short2ShortLinkedOpenHashMap extends Short2ShortOpenHashMap impleme public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2BooleanOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2BooleanOpenHashMap.java index 115d75e..242bb05 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2BooleanOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2BooleanOpenHashMap.java @@ -30,7 +30,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectBooleanConsumer; import speiger.src.collections.booleans.functions.function.BooleanPredicate; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -73,7 +73,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient BooleanCollection valuesC; + protected transient BooleanOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -258,6 +258,10 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap @Override public boolean putAndMoveToLast(short key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(short key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(short key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -360,7 +364,24 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap public boolean lastBooleanValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2BooleanEntrySet() { @@ -375,7 +396,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -524,24 +545,29 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap public boolean moveToLast(Short2BooleanMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2BooleanMap.Entry first() { + public Short2BooleanMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstBooleanValue()); } @Override - public Short2BooleanMap.Entry last() { + public Short2BooleanMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastBooleanValue()); } @Override - public Short2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -551,7 +577,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -766,7 +792,12 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -786,20 +817,20 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -926,30 +957,35 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2BooleanOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2BooleanOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { throw new UnsupportedOperationException(); } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { throw new UnsupportedOperationException(); } @Override public void forEach(BooleanConsumer action) { int index = firstIndex; @@ -1078,7 +1114,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1104,7 +1140,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1131,7 +1167,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1153,7 +1189,7 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap } private class ValueIterator extends MapIterator implements BooleanListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public boolean previousBoolean() { @@ -1174,13 +1210,16 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1211,11 +1250,11 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1232,20 +1271,30 @@ public class ImmutableShort2BooleanOpenHashMap extends AbstractShort2BooleanMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ByteOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ByteOpenHashMap.java index 537470e..628423a 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ByteOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ByteOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectByteConsumer; import speiger.src.collections.bytes.functions.function.BytePredicate; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient ByteCollection valuesC; + protected transient ByteOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem @Override public byte putAndMoveToLast(short key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(short key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(short key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem public byte lastByteValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2ByteEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem public boolean moveToLast(Short2ByteMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2ByteMap.Entry first() { + public Short2ByteMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstByteValue()); } @Override - public Short2ByteMap.Entry last() { + public Short2ByteMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastByteValue()); } @Override - public Short2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2ByteOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2ByteOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { throw new UnsupportedOperationException(); } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { throw new UnsupportedOperationException(); } @Override public void forEach(ByteConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem } private class ValueIterator extends MapIterator implements ByteListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public byte previousByte() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2ByteOpenHashMap extends AbstractShort2ByteMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2CharOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2CharOpenHashMap.java index dadecbc..804f35b 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2CharOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2CharOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectCharConsumer; import speiger.src.collections.chars.functions.function.CharPredicate; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient CharCollection valuesC; + protected transient CharOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem @Override public char putAndMoveToLast(short key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(short key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(short key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem public char lastCharValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2CharEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem public boolean moveToLast(Short2CharMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2CharMap.Entry first() { + public Short2CharMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstCharValue()); } @Override - public Short2CharMap.Entry last() { + public Short2CharMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastCharValue()); } @Override - public Short2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2CharOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2CharOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { throw new UnsupportedOperationException(); } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { throw new UnsupportedOperationException(); } @Override public void forEach(CharConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem } private class ValueIterator extends MapIterator implements CharListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public char previousChar() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2CharOpenHashMap extends AbstractShort2CharMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2DoubleOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2DoubleOpenHashMap.java index 01c27cc..31b50ec 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2DoubleOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2DoubleOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectDoubleConsumer; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient DoubleCollection valuesC; + protected transient DoubleOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im @Override public double putAndMoveToLast(short key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(short key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(short key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im public double lastDoubleValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2DoubleEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im public boolean moveToLast(Short2DoubleMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2DoubleMap.Entry first() { + public Short2DoubleMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstDoubleValue()); } @Override - public Short2DoubleMap.Entry last() { + public Short2DoubleMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastDoubleValue()); } @Override - public Short2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2DoubleOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2DoubleOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { throw new UnsupportedOperationException(); } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { throw new UnsupportedOperationException(); } @Override public void forEach(DoubleConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im } private class ValueIterator extends MapIterator implements DoubleListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public double previousDouble() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2DoubleOpenHashMap extends AbstractShort2DoubleMap im public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2FloatOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2FloatOpenHashMap.java index 787248f..739efde 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2FloatOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2FloatOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectFloatConsumer; import speiger.src.collections.floats.functions.function.FloatPredicate; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient FloatCollection valuesC; + protected transient FloatOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl @Override public float putAndMoveToLast(short key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(short key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(short key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl public float lastFloatValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2FloatEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl public boolean moveToLast(Short2FloatMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2FloatMap.Entry first() { + public Short2FloatMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstFloatValue()); } @Override - public Short2FloatMap.Entry last() { + public Short2FloatMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastFloatValue()); } @Override - public Short2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2FloatOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2FloatOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { throw new UnsupportedOperationException(); } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { throw new UnsupportedOperationException(); } @Override public void forEach(FloatConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl } private class ValueIterator extends MapIterator implements FloatListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public float previousFloat() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2FloatOpenHashMap extends AbstractShort2FloatMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2IntOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2IntOpenHashMap.java index da1291c..f2c6634 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2IntOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2IntOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectIntConsumer; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient IntCollection valuesC; + protected transient IntOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen @Override public int putAndMoveToLast(short key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(short key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(short key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen public int lastIntValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2IntEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen public boolean moveToLast(Short2IntMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2IntMap.Entry first() { + public Short2IntMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstIntValue()); } @Override - public Short2IntMap.Entry last() { + public Short2IntMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastIntValue()); } @Override - public Short2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2IntOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2IntOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { throw new UnsupportedOperationException(); } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { throw new UnsupportedOperationException(); } @Override public void forEach(IntConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen } private class ValueIterator extends MapIterator implements IntListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public int previousInt() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2IntOpenHashMap extends AbstractShort2IntMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2LongOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2LongOpenHashMap.java index a176f39..f920cf7 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2LongOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2LongOpenHashMap.java @@ -31,7 +31,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectLongConsumer; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -74,7 +74,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient LongCollection valuesC; + protected transient LongOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -263,6 +263,10 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem @Override public long putAndMoveToLast(short key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(short key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(short key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -365,7 +369,24 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem public long lastLongValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2LongEntrySet() { @@ -380,7 +401,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -529,24 +550,29 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem public boolean moveToLast(Short2LongMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2LongMap.Entry first() { + public Short2LongMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstLongValue()); } @Override - public Short2LongMap.Entry last() { + public Short2LongMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastLongValue()); } @Override - public Short2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -556,7 +582,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -771,7 +797,12 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -791,20 +822,20 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -931,30 +962,35 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2LongOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2LongOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { throw new UnsupportedOperationException(); } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { throw new UnsupportedOperationException(); } @Override public void forEach(LongConsumer action) { int index = firstIndex; @@ -1083,7 +1119,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1109,7 +1145,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1136,7 +1172,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1158,7 +1194,7 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem } private class ValueIterator extends MapIterator implements LongListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public long previousLong() { @@ -1179,13 +1215,16 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1216,11 +1255,11 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1237,20 +1276,30 @@ public class ImmutableShort2LongOpenHashMap extends AbstractShort2LongMap implem public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ObjectOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ObjectOpenHashMap.java index e4bd9b4..b9b8c60 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ObjectOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ObjectOpenHashMap.java @@ -28,7 +28,7 @@ import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -68,7 +68,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient ObjectCollection valuesC; + protected transient ObjectOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -253,6 +253,10 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap @Override public V putAndMoveToLast(short key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(short key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(short key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -344,7 +348,24 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap public V lastValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet> short2ObjectEntrySet() { @@ -359,7 +380,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -500,24 +521,29 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap public boolean moveToLast(Short2ObjectMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2ObjectMap.Entry first() { + public Short2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstShortKey(), firstValue()); } @Override - public Short2ObjectMap.Entry last() { + public Short2ObjectMap.Entry getLast() { return new BasicEntry<>(lastShortKey(), lastValue()); } @Override - public Short2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -527,7 +553,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -742,7 +768,12 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -762,20 +793,20 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -902,31 +933,36 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override @Deprecated - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2ObjectOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2ObjectOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { throw new UnsupportedOperationException(); } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { throw new UnsupportedOperationException(); } @Override public void forEach(Consumer action) { int index = firstIndex; @@ -1055,7 +1091,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1081,7 +1117,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap private class EntryIterator extends MapIterator implements ObjectListIterator> { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1108,7 +1144,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1130,7 +1166,7 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap } private class ValueIterator extends MapIterator implements ObjectListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public V previous() { @@ -1151,13 +1187,16 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1188,11 +1227,11 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1209,20 +1248,30 @@ public class ImmutableShort2ObjectOpenHashMap extends AbstractShort2ObjectMap public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ShortOpenHashMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ShortOpenHashMap.java index 9ed403e..11612f8 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ShortOpenHashMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/immutable/ImmutableShort2ShortOpenHashMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.shorts.utils.ShortArrays; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; @@ -65,7 +65,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl /** KeySet cache */ protected transient ShortOrderedSet keySet; /** Values cache */ - protected transient ShortCollection valuesC; + protected transient ShortOrderedCollection valuesC; /** Amount of Elements stored in the HashMap */ protected int size; @@ -254,6 +254,10 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl @Override public short putAndMoveToLast(short key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(short key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(short key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -356,7 +360,24 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl public short lastShortValue() { if(size == 0) throw new NoSuchElementException(); return values[lastIndex]; - } + } + + @Override + public Short2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[firstIndex], values[firstIndex]); + } + + @Override + public Short2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[lastIndex], values[lastIndex]); + } + + @Override + public Short2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } @Override public ObjectOrderedSet short2ShortEntrySet() { @@ -371,7 +392,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -520,24 +541,29 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl public boolean moveToLast(Short2ShortMap.Entry o) { throw new UnsupportedOperationException(); } @Override - public Short2ShortMap.Entry first() { + public Short2ShortMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstShortValue()); } @Override - public Short2ShortMap.Entry last() { + public Short2ShortMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastShortValue()); } @Override - public Short2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -547,7 +573,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -762,7 +788,12 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl @Override public ShortListIterator iterator() { - return new KeyIterator(); + return new KeyIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new KeyIterator(false); } @Override @@ -782,20 +813,20 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl public void clear() { throw new UnsupportedOperationException(); } @Override - public short firstShort() { + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { @@ -922,30 +953,35 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return ImmutableShort2ShortOpenHashMap.this.size(); - } - + public int size() { return ImmutableShort2ShortOpenHashMap.this.size(); } @Override public void clear() { throw new UnsupportedOperationException(); } - + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public void forEach(ShortConsumer action) { int index = firstIndex; @@ -1074,7 +1110,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} + public FastEntryIterator(boolean start) { super(start); } public FastEntryIterator(short from) { super(from); } @@ -1100,7 +1136,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl private class EntryIterator extends MapIterator implements ObjectListIterator { - public EntryIterator() {} + public EntryIterator(boolean start) { super(start); } public EntryIterator(short from) { super(from); } @@ -1127,7 +1163,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} + public KeyIterator(boolean start) { super(start); } public KeyIterator(short from) { super(from); } @@ -1149,7 +1185,7 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl } private class ValueIterator extends MapIterator implements ShortListIterator { - public ValueIterator() {} + public ValueIterator(boolean start) { super(start); } @Override public short previousShort() { @@ -1170,13 +1206,16 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl } private class MapIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; int index = 0; - MapIterator() { - next = firstIndex; + MapIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } MapIterator(short from) { @@ -1207,11 +1246,11 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl } public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } public int nextIndex() { @@ -1228,20 +1267,30 @@ public class ImmutableShort2ShortOpenHashMap extends AbstractShort2ShortMap impl public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - current = previous; - previous = (int)(links[current] >> 32); - next = current; + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return current; } public int nextEntry() { if(!hasNext()) throw new NoSuchElementException(); + if(forward) moveForwards(); + else moveBackwards(); + if(index >= 0) index++; + return current; + } + + private void moveBackwards() { + current = previous; + previous = (int)(links[current] >> 32); + next = current; + } + + private void moveForwards() { current = next; next = (int)(links[current]); previous = current; - if(index >= 0) index++; - return current; } private void ensureIndexKnown() { diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2BooleanArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2BooleanArrayMap.java index 551da09..78a681c 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2BooleanArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2BooleanArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2BooleanOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.booleans.collections.AbstractBooleanCollection; -import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.collections.BooleanIterator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; @@ -62,7 +62,7 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected BooleanCollection valuesC; + protected BooleanOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -206,6 +206,27 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S return lastValue; } + @Override + public boolean putFirst(short key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public boolean putLast(short key, boolean value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -320,6 +341,34 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S return result; } + @Override + public Short2BooleanMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2BooleanMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2BooleanMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2BooleanMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public boolean remove(short key) { int index = findIndex(key); @@ -377,7 +426,7 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } @Override - public BooleanCollection values() { + public BooleanOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -695,24 +744,24 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } @Override - public Short2BooleanMap.Entry first() { + public Short2BooleanMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstBooleanValue()); } @Override - public Short2BooleanMap.Entry last() { + public Short2BooleanMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastBooleanValue()); } @Override - public Short2BooleanMap.Entry pollFirst() { + public Short2BooleanMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstBooleanValue()); pollFirstShortKey(); return entry; } @Override - public Short2BooleanMap.Entry pollLast() { + public Short2BooleanMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastBooleanValue()); pollLastShortKey(); return entry; @@ -720,7 +769,12 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -730,7 +784,7 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -927,7 +981,9 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S @Override public boolean moveToLast(short o) { return Short2BooleanArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -935,13 +991,13 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S @Override public void clear() { Short2BooleanArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1038,32 +1094,43 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } } - private class Values extends AbstractBooleanCollection { + private class Values extends AbstractBooleanCollection implements BooleanOrderedCollection { @Override - public boolean contains(boolean e) { - return containsValue(e); - } + public boolean contains(boolean e) { return containsValue(e); } @Override - public boolean add(boolean o) { - throw new UnsupportedOperationException(); - } - + public boolean add(boolean o) { throw new UnsupportedOperationException(); } @Override - public BooleanIterator iterator() { - return new ValueIterator(); - } - + public BooleanIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2BooleanArrayMap.this.size(); - } - + public int size() { return Short2BooleanArrayMap.this.size(); } @Override - public void clear() { - Short2BooleanArrayMap.this.clear(); + public void clear() { Short2BooleanArrayMap.this.clear(); } + @Override + public BooleanOrderedCollection reversed() { return new AbstractBooleanCollection.ReverseBooleanOrderedCollection(this, this::reverseIterator); } + private BooleanIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(boolean e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(boolean e) { throw new UnsupportedOperationException(); } + @Override + public boolean getFirstBoolean() { return firstBooleanValue(); } + @Override + public boolean removeFirstBoolean() { + boolean result = firstBooleanValue(); + pollFirstShortKey(); + return result; + } + @Override + public boolean getLastBoolean() { return lastBooleanValue(); } + @Override + public boolean removeLastBoolean() { + boolean result = lastBooleanValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(BooleanConsumer action) { Objects.requireNonNull(action); @@ -1152,10 +1219,8 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2BooleanMap.Entry next() { @@ -1178,11 +1243,8 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2BooleanMap.Entry next() { @@ -1209,11 +1271,8 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1233,6 +1292,9 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } private class ValueIterator extends MapIterator implements BooleanListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public boolean previousBoolean() { return values[previousEntry()]; @@ -1251,23 +1313,37 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1280,26 +1356,42 @@ public class Short2BooleanArrayMap extends AbstractShort2BooleanMap implements S public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ByteArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ByteArrayMap.java index a88c306..5e84fd2 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ByteArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ByteArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ByteOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.bytes.collections.AbstractByteCollection; -import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.collections.ByteIterator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; @@ -63,7 +63,7 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected ByteCollection valuesC; + protected ByteOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B return lastValue; } + @Override + public byte putFirst(short key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public byte putLast(short key, byte value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B return result; } + @Override + public Short2ByteMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2ByteMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2ByteMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2ByteMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public byte remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } @Override - public ByteCollection values() { + public ByteOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } @Override - public Short2ByteMap.Entry first() { + public Short2ByteMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstByteValue()); } @Override - public Short2ByteMap.Entry last() { + public Short2ByteMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastByteValue()); } @Override - public Short2ByteMap.Entry pollFirst() { + public Short2ByteMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstByteValue()); pollFirstShortKey(); return entry; } @Override - public Short2ByteMap.Entry pollLast() { + public Short2ByteMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastByteValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B @Override public boolean moveToLast(short o) { return Short2ByteArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B @Override public void clear() { Short2ByteArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } } - private class Values extends AbstractByteCollection { + private class Values extends AbstractByteCollection implements ByteOrderedCollection { @Override - public boolean contains(byte e) { - return containsValue(e); - } + public boolean contains(byte e) { return containsValue(e); } @Override - public boolean add(byte o) { - throw new UnsupportedOperationException(); - } - + public boolean add(byte o) { throw new UnsupportedOperationException(); } @Override - public ByteIterator iterator() { - return new ValueIterator(); - } - + public ByteIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ByteArrayMap.this.size(); - } - + public int size() { return Short2ByteArrayMap.this.size(); } @Override - public void clear() { - Short2ByteArrayMap.this.clear(); + public void clear() { Short2ByteArrayMap.this.clear(); } + @Override + public ByteOrderedCollection reversed() { return new AbstractByteCollection.ReverseByteOrderedCollection(this, this::reverseIterator); } + private ByteIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(byte e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(byte e) { throw new UnsupportedOperationException(); } + @Override + public byte getFirstByte() { return firstByteValue(); } + @Override + public byte removeFirstByte() { + byte result = firstByteValue(); + pollFirstShortKey(); + return result; + } + @Override + public byte getLastByte() { return lastByteValue(); } + @Override + public byte removeLastByte() { + byte result = lastByteValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(ByteConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2ByteMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2ByteMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } private class ValueIterator extends MapIterator implements ByteListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public byte previousByte() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2ByteArrayMap extends AbstractShort2ByteMap implements Short2B public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2CharArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2CharArrayMap.java index e97000d..80b6c60 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2CharArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2CharArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2CharOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.chars.collections.AbstractCharCollection; -import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.collections.CharIterator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; @@ -63,7 +63,7 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected CharCollection valuesC; + protected CharOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C return lastValue; } + @Override + public char putFirst(short key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public char putLast(short key, char value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C return result; } + @Override + public Short2CharMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2CharMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2CharMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2CharMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public char remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } @Override - public CharCollection values() { + public CharOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } @Override - public Short2CharMap.Entry first() { + public Short2CharMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstCharValue()); } @Override - public Short2CharMap.Entry last() { + public Short2CharMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastCharValue()); } @Override - public Short2CharMap.Entry pollFirst() { + public Short2CharMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstCharValue()); pollFirstShortKey(); return entry; } @Override - public Short2CharMap.Entry pollLast() { + public Short2CharMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastCharValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C @Override public boolean moveToLast(short o) { return Short2CharArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C @Override public void clear() { Short2CharArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } } - private class Values extends AbstractCharCollection { + private class Values extends AbstractCharCollection implements CharOrderedCollection { @Override - public boolean contains(char e) { - return containsValue(e); - } + public boolean contains(char e) { return containsValue(e); } @Override - public boolean add(char o) { - throw new UnsupportedOperationException(); - } - + public boolean add(char o) { throw new UnsupportedOperationException(); } @Override - public CharIterator iterator() { - return new ValueIterator(); - } - + public CharIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2CharArrayMap.this.size(); - } - + public int size() { return Short2CharArrayMap.this.size(); } @Override - public void clear() { - Short2CharArrayMap.this.clear(); + public void clear() { Short2CharArrayMap.this.clear(); } + @Override + public CharOrderedCollection reversed() { return new AbstractCharCollection.ReverseCharOrderedCollection(this, this::reverseIterator); } + private CharIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(char e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(char e) { throw new UnsupportedOperationException(); } + @Override + public char getFirstChar() { return firstCharValue(); } + @Override + public char removeFirstChar() { + char result = firstCharValue(); + pollFirstShortKey(); + return result; + } + @Override + public char getLastChar() { return lastCharValue(); } + @Override + public char removeLastChar() { + char result = lastCharValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(CharConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2CharMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2CharMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } private class ValueIterator extends MapIterator implements CharListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public char previousChar() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2CharArrayMap extends AbstractShort2CharMap implements Short2C public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2DoubleArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2DoubleArrayMap.java index a59d79a..c64897d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2DoubleArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2DoubleArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2DoubleOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.doubles.collections.AbstractDoubleCollection; -import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.collections.DoubleIterator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; @@ -63,7 +63,7 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected DoubleCollection valuesC; + protected DoubleOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho return lastValue; } + @Override + public double putFirst(short key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public double putLast(short key, double value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho return result; } + @Override + public Short2DoubleMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2DoubleMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2DoubleMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2DoubleMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public double remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } @Override - public DoubleCollection values() { + public DoubleOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } @Override - public Short2DoubleMap.Entry first() { + public Short2DoubleMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstDoubleValue()); } @Override - public Short2DoubleMap.Entry last() { + public Short2DoubleMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastDoubleValue()); } @Override - public Short2DoubleMap.Entry pollFirst() { + public Short2DoubleMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstDoubleValue()); pollFirstShortKey(); return entry; } @Override - public Short2DoubleMap.Entry pollLast() { + public Short2DoubleMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastDoubleValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho @Override public boolean moveToLast(short o) { return Short2DoubleArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho @Override public void clear() { Short2DoubleArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } } - private class Values extends AbstractDoubleCollection { + private class Values extends AbstractDoubleCollection implements DoubleOrderedCollection { @Override - public boolean contains(double e) { - return containsValue(e); - } + public boolean contains(double e) { return containsValue(e); } @Override - public boolean add(double o) { - throw new UnsupportedOperationException(); - } - + public boolean add(double o) { throw new UnsupportedOperationException(); } @Override - public DoubleIterator iterator() { - return new ValueIterator(); - } - + public DoubleIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2DoubleArrayMap.this.size(); - } - + public int size() { return Short2DoubleArrayMap.this.size(); } @Override - public void clear() { - Short2DoubleArrayMap.this.clear(); + public void clear() { Short2DoubleArrayMap.this.clear(); } + @Override + public DoubleOrderedCollection reversed() { return new AbstractDoubleCollection.ReverseDoubleOrderedCollection(this, this::reverseIterator); } + private DoubleIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(double e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(double e) { throw new UnsupportedOperationException(); } + @Override + public double getFirstDouble() { return firstDoubleValue(); } + @Override + public double removeFirstDouble() { + double result = firstDoubleValue(); + pollFirstShortKey(); + return result; + } + @Override + public double getLastDouble() { return lastDoubleValue(); } + @Override + public double removeLastDouble() { + double result = lastDoubleValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(DoubleConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2DoubleMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2DoubleMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } private class ValueIterator extends MapIterator implements DoubleListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public double previousDouble() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2DoubleArrayMap extends AbstractShort2DoubleMap implements Sho public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2FloatArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2FloatArrayMap.java index c5a7b00..2fa6dbf 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2FloatArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2FloatArrayMap.java @@ -26,7 +26,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2FloatOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.floats.collections.AbstractFloatCollection; -import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.collections.FloatIterator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; @@ -63,7 +63,7 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected FloatCollection valuesC; + protected FloatOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short return lastValue; } + @Override + public float putFirst(short key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public float putLast(short key, float value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short return result; } + @Override + public Short2FloatMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2FloatMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2FloatMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2FloatMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public float remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } @Override - public FloatCollection values() { + public FloatOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } @Override - public Short2FloatMap.Entry first() { + public Short2FloatMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstFloatValue()); } @Override - public Short2FloatMap.Entry last() { + public Short2FloatMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastFloatValue()); } @Override - public Short2FloatMap.Entry pollFirst() { + public Short2FloatMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstFloatValue()); pollFirstShortKey(); return entry; } @Override - public Short2FloatMap.Entry pollLast() { + public Short2FloatMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastFloatValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short @Override public boolean moveToLast(short o) { return Short2FloatArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short @Override public void clear() { Short2FloatArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } } - private class Values extends AbstractFloatCollection { + private class Values extends AbstractFloatCollection implements FloatOrderedCollection { @Override - public boolean contains(float e) { - return containsValue(e); - } + public boolean contains(float e) { return containsValue(e); } @Override - public boolean add(float o) { - throw new UnsupportedOperationException(); - } - + public boolean add(float o) { throw new UnsupportedOperationException(); } @Override - public FloatIterator iterator() { - return new ValueIterator(); - } - + public FloatIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2FloatArrayMap.this.size(); - } - + public int size() { return Short2FloatArrayMap.this.size(); } @Override - public void clear() { - Short2FloatArrayMap.this.clear(); + public void clear() { Short2FloatArrayMap.this.clear(); } + @Override + public FloatOrderedCollection reversed() { return new AbstractFloatCollection.ReverseFloatOrderedCollection(this, this::reverseIterator); } + private FloatIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(float e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(float e) { throw new UnsupportedOperationException(); } + @Override + public float getFirstFloat() { return firstFloatValue(); } + @Override + public float removeFirstFloat() { + float result = firstFloatValue(); + pollFirstShortKey(); + return result; + } + @Override + public float getLastFloat() { return lastFloatValue(); } + @Override + public float removeLastFloat() { + float result = lastFloatValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(FloatConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2FloatMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2FloatMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } private class ValueIterator extends MapIterator implements FloatListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public float previousFloat() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2FloatArrayMap extends AbstractShort2FloatMap implements Short public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2IntArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2IntArrayMap.java index 5845690..8c4bc96 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2IntArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2IntArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2IntOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.ints.collections.AbstractIntCollection; -import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.collections.IntIterator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; @@ -63,7 +63,7 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected IntCollection valuesC; + protected IntOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int return lastValue; } + @Override + public int putFirst(short key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public int putLast(short key, int value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int return result; } + @Override + public Short2IntMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2IntMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2IntMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2IntMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public int remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } @Override - public IntCollection values() { + public IntOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } @Override - public Short2IntMap.Entry first() { + public Short2IntMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstIntValue()); } @Override - public Short2IntMap.Entry last() { + public Short2IntMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastIntValue()); } @Override - public Short2IntMap.Entry pollFirst() { + public Short2IntMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstIntValue()); pollFirstShortKey(); return entry; } @Override - public Short2IntMap.Entry pollLast() { + public Short2IntMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastIntValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int @Override public boolean moveToLast(short o) { return Short2IntArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int @Override public void clear() { Short2IntArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } } - private class Values extends AbstractIntCollection { + private class Values extends AbstractIntCollection implements IntOrderedCollection { @Override - public boolean contains(int e) { - return containsValue(e); - } + public boolean contains(int e) { return containsValue(e); } @Override - public boolean add(int o) { - throw new UnsupportedOperationException(); - } - + public boolean add(int o) { throw new UnsupportedOperationException(); } @Override - public IntIterator iterator() { - return new ValueIterator(); - } - + public IntIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2IntArrayMap.this.size(); - } - + public int size() { return Short2IntArrayMap.this.size(); } @Override - public void clear() { - Short2IntArrayMap.this.clear(); + public void clear() { Short2IntArrayMap.this.clear(); } + @Override + public IntOrderedCollection reversed() { return new AbstractIntCollection.ReverseIntOrderedCollection(this, this::reverseIterator); } + private IntIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(int e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(int e) { throw new UnsupportedOperationException(); } + @Override + public int getFirstInt() { return firstIntValue(); } + @Override + public int removeFirstInt() { + int result = firstIntValue(); + pollFirstShortKey(); + return result; + } + @Override + public int getLastInt() { return lastIntValue(); } + @Override + public int removeLastInt() { + int result = lastIntValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(IntConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2IntMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2IntMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } private class ValueIterator extends MapIterator implements IntListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public int previousInt() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2IntArrayMap extends AbstractShort2IntMap implements Short2Int public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2LongArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2LongArrayMap.java index 7080b30..f9a73dc 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2LongArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2LongArrayMap.java @@ -27,7 +27,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2LongOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.longs.collections.AbstractLongCollection; -import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.collections.LongIterator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; @@ -63,7 +63,7 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected LongCollection valuesC; + protected LongOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -229,6 +229,27 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L return lastValue; } + @Override + public long putFirst(short key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public long putLast(short key, long value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -343,6 +364,34 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L return result; } + @Override + public Short2LongMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2LongMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2LongMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2LongMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public long remove(short key) { int index = findIndex(key); @@ -400,7 +449,7 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } @Override - public LongCollection values() { + public LongOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -718,24 +767,24 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } @Override - public Short2LongMap.Entry first() { + public Short2LongMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstLongValue()); } @Override - public Short2LongMap.Entry last() { + public Short2LongMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastLongValue()); } @Override - public Short2LongMap.Entry pollFirst() { + public Short2LongMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstLongValue()); pollFirstShortKey(); return entry; } @Override - public Short2LongMap.Entry pollLast() { + public Short2LongMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastLongValue()); pollLastShortKey(); return entry; @@ -743,7 +792,12 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -753,7 +807,7 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -950,7 +1004,9 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L @Override public boolean moveToLast(short o) { return Short2LongArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -958,13 +1014,13 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L @Override public void clear() { Short2LongArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1061,32 +1117,43 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } } - private class Values extends AbstractLongCollection { + private class Values extends AbstractLongCollection implements LongOrderedCollection { @Override - public boolean contains(long e) { - return containsValue(e); - } + public boolean contains(long e) { return containsValue(e); } @Override - public boolean add(long o) { - throw new UnsupportedOperationException(); - } - + public boolean add(long o) { throw new UnsupportedOperationException(); } @Override - public LongIterator iterator() { - return new ValueIterator(); - } - + public LongIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2LongArrayMap.this.size(); - } - + public int size() { return Short2LongArrayMap.this.size(); } @Override - public void clear() { - Short2LongArrayMap.this.clear(); + public void clear() { Short2LongArrayMap.this.clear(); } + @Override + public LongOrderedCollection reversed() { return new AbstractLongCollection.ReverseLongOrderedCollection(this, this::reverseIterator); } + private LongIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(long e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(long e) { throw new UnsupportedOperationException(); } + @Override + public long getFirstLong() { return firstLongValue(); } + @Override + public long removeFirstLong() { + long result = firstLongValue(); + pollFirstShortKey(); + return result; + } + @Override + public long getLastLong() { return lastLongValue(); } + @Override + public long removeLastLong() { + long result = lastLongValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(LongConsumer action) { Objects.requireNonNull(action); @@ -1175,10 +1242,8 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2LongMap.Entry next() { @@ -1201,11 +1266,8 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2LongMap.Entry next() { @@ -1232,11 +1294,8 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1256,6 +1315,9 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } private class ValueIterator extends MapIterator implements LongListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public long previousLong() { return values[previousEntry()]; @@ -1274,23 +1336,37 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1303,26 +1379,42 @@ public class Short2LongArrayMap extends AbstractShort2LongMap implements Short2L public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ObjectArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ObjectArrayMap.java index be0d91a..59462a2 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ObjectArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ObjectArrayMap.java @@ -25,7 +25,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ObjectOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.AbstractObjectCollection; -import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.collections.ObjectIterator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; @@ -58,7 +58,7 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected ObjectCollection valuesC; + protected ObjectOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -202,6 +202,27 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen return lastValue; } + @Override + public V putFirst(short key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public V putLast(short key, V value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -311,6 +332,34 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen return result; } + @Override + public Short2ObjectMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[0], values[0]); + } + + @Override + public Short2ObjectMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry<>(keys[size-1], values[size-1]); + } + + @Override + public Short2ObjectMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2ObjectMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry<>(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public V remove(short key) { int index = findIndex(key); @@ -368,7 +417,7 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } @Override - public ObjectCollection values() { + public ObjectOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -631,24 +680,24 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } @Override - public Short2ObjectMap.Entry first() { + public Short2ObjectMap.Entry getFirst() { return new BasicEntry<>(firstShortKey(), firstValue()); } @Override - public Short2ObjectMap.Entry last() { + public Short2ObjectMap.Entry getLast() { return new BasicEntry<>(lastShortKey(), lastValue()); } @Override - public Short2ObjectMap.Entry pollFirst() { + public Short2ObjectMap.Entry removeFirst() { BasicEntry entry = new BasicEntry<>(firstShortKey(), firstValue()); pollFirstShortKey(); return entry; } @Override - public Short2ObjectMap.Entry pollLast() { + public Short2ObjectMap.Entry removeLast() { BasicEntry entry = new BasicEntry<>(lastShortKey(), lastValue()); pollLastShortKey(); return entry; @@ -656,7 +705,12 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen @Override public ObjectBidirectionalIterator> iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator> reverseIterator() { + return new EntryIterator(false); } @Override @@ -666,7 +720,7 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen @Override public ObjectBidirectionalIterator> fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -863,7 +917,9 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen @Override public boolean moveToLast(short o) { return Short2ObjectArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -871,13 +927,13 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen @Override public void clear() { Short2ObjectArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -974,32 +1030,43 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } } - private class Values extends AbstractObjectCollection { + private class Values extends AbstractObjectCollection implements ObjectOrderedCollection { @Override - public boolean contains(Object e) { - return containsValue(e); - } + public boolean contains(Object e) { return containsValue(e); } @Override - public boolean add(V o) { - throw new UnsupportedOperationException(); - } - + public boolean add(V o) { throw new UnsupportedOperationException(); } @Override - public ObjectIterator iterator() { - return new ValueIterator(); - } - + public ObjectIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ObjectArrayMap.this.size(); - } - + public int size() { return Short2ObjectArrayMap.this.size(); } @Override - public void clear() { - Short2ObjectArrayMap.this.clear(); + public void clear() { Short2ObjectArrayMap.this.clear(); } + @Override + public ObjectOrderedCollection reversed() { return new AbstractObjectCollection.ReverseObjectOrderedCollection<>(this, this::reverseIterator); } + private ObjectIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(V e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(V e) { throw new UnsupportedOperationException(); } + @Override + public V getFirst() { return firstValue(); } + @Override + public V removeFirst() { + V result = firstValue(); + pollFirstShortKey(); + return result; + } + @Override + public V getLast() { return lastValue(); } + @Override + public V removeLast() { + V result = lastValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(Consumer action) { Objects.requireNonNull(action); @@ -1088,10 +1155,8 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen private class FastEntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2ObjectMap.Entry next() { @@ -1114,11 +1179,8 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen private class EntryIterator extends MapIterator implements ObjectListIterator> { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2ObjectMap.Entry next() { @@ -1145,11 +1207,8 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1169,6 +1228,9 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } private class ValueIterator extends MapIterator implements ObjectListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public V previous() { return values[previousEntry()]; @@ -1187,23 +1249,37 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1216,26 +1292,42 @@ public class Short2ObjectArrayMap extends AbstractShort2ObjectMap implemen public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ShortArrayMap.java b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ShortArrayMap.java index b9b3bbf..da53df5 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ShortArrayMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/impl/misc/Short2ShortArrayMap.java @@ -24,7 +24,7 @@ import speiger.src.collections.shorts.maps.interfaces.Short2ShortOrderedMap; import speiger.src.collections.shorts.sets.AbstractShortSet; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.collections.AbstractShortCollection; -import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.objects.functions.consumer.ObjectObjectConsumer; @@ -56,7 +56,7 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short /** KeySet cache */ protected ShortOrderedSet keySet; /** Values cache */ - protected ShortCollection valuesC; + protected ShortOrderedCollection valuesC; /** EntrySet cache */ protected FastOrderedSet entrySet; @@ -222,6 +222,27 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short return lastValue; } + @Override + public short putFirst(short key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(0, key, value); + size++; + return getDefaultReturnValue(); + } + return values[index]; + } + + @Override + public short putLast(short key, short value) { + int index = findIndex(key); + if(index < 0) { + insertIndex(size++, key, value); + return getDefaultReturnValue(); + } + return values[index]; + } + @Override public boolean moveToFirst(short key) { int index = findIndex(key); @@ -336,6 +357,34 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short return result; } + @Override + public Short2ShortMap.Entry firstEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[0], values[0]); + } + + @Override + public Short2ShortMap.Entry lastEntry() { + if(size == 0) throw new NoSuchElementException(); + return new BasicEntry(keys[size-1], values[size-1]); + } + + @Override + public Short2ShortMap.Entry pollFirstEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[0], values[0]); + removeIndex(0); + return result; + } + + @Override + public Short2ShortMap.Entry pollLastEntry() { + if(size == 0) throw new NoSuchElementException(); + BasicEntry result = new BasicEntry(keys[size-1], values[size-1]); + removeIndex(size-1); + return result; + } + @Override public short remove(short key) { int index = findIndex(key); @@ -393,7 +442,7 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } @Override - public ShortCollection values() { + public ShortOrderedCollection values() { if(valuesC == null) valuesC = new Values(); return valuesC; } @@ -711,24 +760,24 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } @Override - public Short2ShortMap.Entry first() { + public Short2ShortMap.Entry getFirst() { return new BasicEntry(firstShortKey(), firstShortValue()); } @Override - public Short2ShortMap.Entry last() { + public Short2ShortMap.Entry getLast() { return new BasicEntry(lastShortKey(), lastShortValue()); } @Override - public Short2ShortMap.Entry pollFirst() { + public Short2ShortMap.Entry removeFirst() { BasicEntry entry = new BasicEntry(firstShortKey(), firstShortValue()); pollFirstShortKey(); return entry; } @Override - public Short2ShortMap.Entry pollLast() { + public Short2ShortMap.Entry removeLast() { BasicEntry entry = new BasicEntry(lastShortKey(), lastShortValue()); pollLastShortKey(); return entry; @@ -736,7 +785,12 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short @Override public ObjectBidirectionalIterator iterator() { - return new EntryIterator(); + return new EntryIterator(true); + } + + @Override + public ObjectBidirectionalIterator reverseIterator() { + return new EntryIterator(false); } @Override @@ -746,7 +800,7 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short @Override public ObjectBidirectionalIterator fastIterator() { - return new FastEntryIterator(); + return new FastEntryIterator(true); } @Override @@ -943,7 +997,9 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short @Override public boolean moveToLast(short o) { return Short2ShortArrayMap.this.moveToLast(o); } @Override - public ShortListIterator iterator() { return new KeyIterator(); } + public ShortListIterator iterator() { return new KeyIterator(true); } + @Override + public ShortListIterator reverseIterator() { return new KeyIterator(false); } @Override public ShortBidirectionalIterator iterator(short fromElement) { return new KeyIterator(fromElement); } @Override @@ -951,13 +1007,13 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short @Override public void clear() { Short2ShortArrayMap.this.clear(); } @Override - public short firstShort() { return firstShortKey(); } + public short getFirstShort() { return firstShortKey(); } @Override - public short pollFirstShort() { return pollFirstShortKey(); } + public short removeFirstShort() { return pollFirstShortKey(); } @Override - public short lastShort() { return lastShortKey(); } + public short getLastShort() { return lastShortKey(); } @Override - public short pollLastShort() { return pollLastShortKey(); } + public short removeLastShort() { return pollLastShortKey(); } @Override public KeySet copy() { throw new UnsupportedOperationException(); } @@ -1054,32 +1110,43 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } } - private class Values extends AbstractShortCollection { + private class Values extends AbstractShortCollection implements ShortOrderedCollection { @Override - public boolean contains(short e) { - return containsValue(e); - } + public boolean contains(short e) { return containsValue(e); } @Override - public boolean add(short o) { - throw new UnsupportedOperationException(); - } - + public boolean add(short o) { throw new UnsupportedOperationException(); } @Override - public ShortIterator iterator() { - return new ValueIterator(); - } - + public ShortIterator iterator() { return new ValueIterator(true); } @Override - public int size() { - return Short2ShortArrayMap.this.size(); - } - + public int size() { return Short2ShortArrayMap.this.size(); } @Override - public void clear() { - Short2ShortArrayMap.this.clear(); + public void clear() { Short2ShortArrayMap.this.clear(); } + @Override + public ShortOrderedCollection reversed() { return new AbstractShortCollection.ReverseShortOrderedCollection(this, this::reverseIterator); } + private ShortIterator reverseIterator() { + return new ValueIterator(false); + } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return firstShortValue(); } + @Override + public short removeFirstShort() { + short result = firstShortValue(); + pollFirstShortKey(); + return result; + } + @Override + public short getLastShort() { return lastShortValue(); } + @Override + public short removeLastShort() { + short result = lastShortValue(); + pollLastShortKey(); + return result; } - @Override public void forEach(ShortConsumer action) { Objects.requireNonNull(action); @@ -1168,10 +1235,8 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short private class FastEntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = new MapEntry(); - public FastEntryIterator() {} - public FastEntryIterator(short from) { - index = findIndex(from); - } + public FastEntryIterator(boolean start) { super(start); } + public FastEntryIterator(short element) { super(element); } @Override public Short2ShortMap.Entry next() { @@ -1194,11 +1259,8 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short private class EntryIterator extends MapIterator implements ObjectListIterator { MapEntry entry = null; - public EntryIterator() {} - public EntryIterator(short from) { - index = findIndex(from); - if(index == -1) throw new NoSuchElementException(); - } + public EntryIterator(boolean start) { super(start); } + public EntryIterator(short element) { super(element); } @Override public Short2ShortMap.Entry next() { @@ -1225,11 +1287,8 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } private class KeyIterator extends MapIterator implements ShortListIterator { - public KeyIterator() {} - public KeyIterator(short element) { - index = findIndex(element); - if(index == -1) throw new NoSuchElementException(); - } + public KeyIterator(boolean start) { super(start); } + public KeyIterator(short element) { super(element); } @Override public short previousShort() { @@ -1249,6 +1308,9 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } private class ValueIterator extends MapIterator implements ShortListIterator { + public ValueIterator(boolean start) { super(start); } + public ValueIterator(short element) { super(element); } + @Override public short previousShort() { return values[previousEntry()]; @@ -1267,23 +1329,37 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short } private class MapIterator { + boolean forward; int index; int lastReturned = -1; - + + MapIterator(boolean start) { + this.forward = start; + this.index = start ? 0 : size; + } + + MapIterator(short element) { + this.forward = true; + index = findIndex(element); + if(index == -1) throw new NoSuchElementException(); + } + public boolean hasNext() { - return index < size; + return forward ? index < size : index > 0; } public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size; } public int nextIndex() { - return index; + if(forward) return index; + return size - index; } public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } public void remove() { @@ -1296,26 +1372,42 @@ public class Short2ShortArrayMap extends AbstractShort2ShortMap implements Short public int previousEntry() { if(!hasPrevious()) throw new NoSuchElementException(); - index--; - return (lastReturned = index); - } - - public int nextEntry() { - if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + index--; + return (lastReturned = index); + } lastReturned = index; return index++; } + public int nextEntry() { + if(!hasNext()) throw new NoSuchElementException(); + if(forward) { + lastReturned = index; + return index++; + } + index--; + return (lastReturned = index); + } + public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanMap.java index b072a67..6c44667 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanMap.java @@ -94,7 +94,7 @@ public interface Short2BooleanMap extends Map, ShortPredicate * @return the last present value or default return value. */ public default Boolean put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().booleanValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanOrderedMap.java index d663d31..add8d6b 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2BooleanOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2BooleanMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2BooleanMap; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2BooleanOrderedMap extends Short2BooleanMap */ public boolean putAndMoveToLast(short key, boolean 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 boolean putFirst(short key, boolean 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 boolean putLast(short key, boolean value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2BooleanOrderedMap extends Short2BooleanMap */ public boolean lastBooleanValue(); + + public Short2BooleanMap.Entry firstEntry(); + + public Short2BooleanMap.Entry lastEntry(); + + public Short2BooleanMap.Entry pollFirstEntry(); + + public Short2BooleanMap.Entry pollLastEntry(); @Override public Short2BooleanOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public BooleanOrderedCollection values(); + @Override public ObjectOrderedSet short2BooleanEntrySet(); + public default Short2BooleanOrderedMap reversed() { return new AbstractShort2BooleanMap.ReversedShort2BooleanOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteMap.java index 58820b1..41de72f 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteMap.java @@ -94,7 +94,7 @@ public interface Short2ByteMap extends Map, Short2ByteFunction * @return the last present value or default return value. */ public default Byte put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().byteValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteOrderedMap.java index 60f753c..444b5b2 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ByteOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2ByteMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2ByteMap; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2ByteOrderedMap extends Short2ByteMap */ public byte putAndMoveToLast(short key, byte 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 byte putFirst(short key, byte 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 byte putLast(short key, byte value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2ByteOrderedMap extends Short2ByteMap */ public byte lastByteValue(); + + public Short2ByteMap.Entry firstEntry(); + + public Short2ByteMap.Entry lastEntry(); + + public Short2ByteMap.Entry pollFirstEntry(); + + public Short2ByteMap.Entry pollLastEntry(); @Override public Short2ByteOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public ByteOrderedCollection values(); + @Override public ObjectOrderedSet short2ByteEntrySet(); + public default Short2ByteOrderedMap reversed() { return new AbstractShort2ByteMap.ReversedShort2ByteOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharMap.java index af57eb2..a5b09a1 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharMap.java @@ -94,7 +94,7 @@ public interface Short2CharMap extends Map, Short2CharFunction * @return the last present value or default return value. */ public default Character put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().charValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharOrderedMap.java index e18b6a5..aee231c 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2CharOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2CharMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2CharMap; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2CharOrderedMap extends Short2CharMap */ public char putAndMoveToLast(short key, char 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 char putFirst(short key, char 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 char putLast(short key, char value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2CharOrderedMap extends Short2CharMap */ public char lastCharValue(); + + public Short2CharMap.Entry firstEntry(); + + public Short2CharMap.Entry lastEntry(); + + public Short2CharMap.Entry pollFirstEntry(); + + public Short2CharMap.Entry pollLastEntry(); @Override public Short2CharOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public CharOrderedCollection values(); + @Override public ObjectOrderedSet short2CharEntrySet(); + public default Short2CharOrderedMap reversed() { return new AbstractShort2CharMap.ReversedShort2CharOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleMap.java index ba98412..4f64d0d 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleMap.java @@ -94,7 +94,7 @@ public interface Short2DoubleMap extends Map, Short2DoubleFunctio * @return the last present value or default return value. */ public default Double put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().doubleValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleOrderedMap.java index 5569924..2d3fd32 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2DoubleOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2DoubleMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2DoubleMap; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2DoubleOrderedMap extends Short2DoubleMap */ public double putAndMoveToLast(short key, double 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 double putFirst(short key, double 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 double putLast(short key, double value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2DoubleOrderedMap extends Short2DoubleMap */ public double lastDoubleValue(); + + public Short2DoubleMap.Entry firstEntry(); + + public Short2DoubleMap.Entry lastEntry(); + + public Short2DoubleMap.Entry pollFirstEntry(); + + public Short2DoubleMap.Entry pollLastEntry(); @Override public Short2DoubleOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public DoubleOrderedCollection values(); + @Override public ObjectOrderedSet short2DoubleEntrySet(); + public default Short2DoubleOrderedMap reversed() { return new AbstractShort2DoubleMap.ReversedShort2DoubleOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatMap.java index 41d117a..e5a8d16 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatMap.java @@ -94,7 +94,7 @@ public interface Short2FloatMap extends Map, Short2FloatFunction * @return the last present value or default return value. */ public default Float put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().floatValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatOrderedMap.java index ff47f23..45c7f2b 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2FloatOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2FloatMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2FloatMap; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2FloatOrderedMap extends Short2FloatMap */ public float putAndMoveToLast(short key, float 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 float putFirst(short key, float 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 float putLast(short key, float value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2FloatOrderedMap extends Short2FloatMap */ public float lastFloatValue(); + + public Short2FloatMap.Entry firstEntry(); + + public Short2FloatMap.Entry lastEntry(); + + public Short2FloatMap.Entry pollFirstEntry(); + + public Short2FloatMap.Entry pollLastEntry(); @Override public Short2FloatOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public FloatOrderedCollection values(); + @Override public ObjectOrderedSet short2FloatEntrySet(); + public default Short2FloatOrderedMap reversed() { return new AbstractShort2FloatMap.ReversedShort2FloatOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntMap.java index 0dc2b8d..1962920 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntMap.java @@ -94,7 +94,7 @@ public interface Short2IntMap extends Map, Short2IntFunction * @return the last present value or default return value. */ public default Integer put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().intValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntOrderedMap.java index adbcfc9..8088b33 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2IntOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2IntMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2IntMap; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2IntOrderedMap extends Short2IntMap */ public int putAndMoveToLast(short key, int 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 int putFirst(short key, int 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 int putLast(short key, int value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2IntOrderedMap extends Short2IntMap */ public int lastIntValue(); + + public Short2IntMap.Entry firstEntry(); + + public Short2IntMap.Entry lastEntry(); + + public Short2IntMap.Entry pollFirstEntry(); + + public Short2IntMap.Entry pollLastEntry(); @Override public Short2IntOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public IntOrderedCollection values(); + @Override public ObjectOrderedSet short2IntEntrySet(); + public default Short2IntOrderedMap reversed() { return new AbstractShort2IntMap.ReversedShort2IntOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongMap.java index 65f039f..cb16a47 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongMap.java @@ -94,7 +94,7 @@ public interface Short2LongMap extends Map, Short2LongFunction * @return the last present value or default return value. */ public default Long put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().longValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongOrderedMap.java index 0d5c3f7..57f4ac9 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2LongOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2LongMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2LongMap; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2LongOrderedMap extends Short2LongMap */ public long putAndMoveToLast(short key, long 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 long putFirst(short key, long 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 long putLast(short key, long value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2LongOrderedMap extends Short2LongMap */ public long lastLongValue(); + + public Short2LongMap.Entry firstEntry(); + + public Short2LongMap.Entry lastEntry(); + + public Short2LongMap.Entry pollFirstEntry(); + + public Short2LongMap.Entry pollLastEntry(); @Override public Short2LongOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public LongOrderedCollection values(); + @Override public ObjectOrderedSet short2LongEntrySet(); + public default Short2LongOrderedMap reversed() { return new AbstractShort2LongMap.ReversedShort2LongOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectMap.java index 82878ee..0636115 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectMap.java @@ -95,7 +95,7 @@ public interface Short2ObjectMap extends Map, ShortFunction * @return the last present value or default return value. */ public default V put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectOrderedMap.java index 9c6bb97..f69f4e5 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ObjectOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2ObjectMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2ObjectMap; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -32,6 +34,26 @@ public interface Short2ObjectOrderedMap extends Short2ObjectMap */ public V putAndMoveToLast(short key, V 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 V putFirst(short key, V 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 V putLast(short key, V value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -92,13 +114,25 @@ public interface Short2ObjectOrderedMap extends Short2ObjectMap */ public V lastValue(); + + public Short2ObjectMap.Entry firstEntry(); + + public Short2ObjectMap.Entry lastEntry(); + + public Short2ObjectMap.Entry pollFirstEntry(); + + public Short2ObjectMap.Entry pollLastEntry(); @Override public Short2ObjectOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public ObjectOrderedCollection values(); + @Override public ObjectOrderedSet> short2ObjectEntrySet(); + public default Short2ObjectOrderedMap reversed() { return new AbstractShort2ObjectMap.ReversedShort2ObjectOrderedMap<>(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortMap.java index 9075120..3e2b761 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortMap.java @@ -93,7 +93,7 @@ public interface Short2ShortMap extends Map, ShortUnaryOperator * @return the last present value or default return value. */ public default Short put(Map.Entry entry) { - return put(entry.getKey(), entry.getValue()); + return put(entry.getKey().shortValue(), entry.getValue().shortValue()); } /** diff --git a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortOrderedMap.java b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortOrderedMap.java index 33f55bc..579ece9 100644 --- a/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortOrderedMap.java +++ b/src/main/java/speiger/src/collections/shorts/maps/interfaces/Short2ShortOrderedMap.java @@ -1,6 +1,8 @@ package speiger.src.collections.shorts.maps.interfaces; import speiger.src.collections.shorts.utils.maps.Short2ShortMaps; +import speiger.src.collections.shorts.maps.abstracts.AbstractShort2ShortMap; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; import speiger.src.collections.objects.sets.ObjectOrderedSet; @@ -31,6 +33,26 @@ public interface Short2ShortOrderedMap extends Short2ShortMap */ public short putAndMoveToLast(short key, short 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 short putFirst(short key, short 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 short putLast(short key, short value); + /** * A specific move method to move a given key/value to the first index. * @param key that should be moved to the first index @@ -91,13 +113,25 @@ public interface Short2ShortOrderedMap extends Short2ShortMap */ public short lastShortValue(); + + public Short2ShortMap.Entry firstEntry(); + + public Short2ShortMap.Entry lastEntry(); + + public Short2ShortMap.Entry pollFirstEntry(); + + public Short2ShortMap.Entry pollLastEntry(); @Override public Short2ShortOrderedMap copy(); @Override public ShortOrderedSet keySet(); @Override + public ShortOrderedCollection values(); + @Override public ObjectOrderedSet short2ShortEntrySet(); + public default Short2ShortOrderedMap reversed() { return new AbstractShort2ShortMap.ReversedShort2ShortOrderedMap(this); } + /** * Creates a Wrapped SortedMap that is Synchronized * @return a new SortedMap that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/sets/AbstractShortSet.java b/src/main/java/speiger/src/collections/shorts/sets/AbstractShortSet.java index 24644f9..4e75d9d 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/AbstractShortSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/AbstractShortSet.java @@ -3,6 +3,7 @@ package speiger.src.collections.shorts.sets; import java.util.Set; import speiger.src.collections.shorts.collections.AbstractShortCollection; +import speiger.src.collections.shorts.collections.ShortBidirectionalIterator; import speiger.src.collections.shorts.collections.ShortIterator; /** @@ -38,4 +39,89 @@ public abstract class AbstractShortSet extends AbstractShortCollection implement return false; } } + + public static class ReversedShortOrderedSet extends AbstractShortSet implements ShortOrderedSet { + protected ShortOrderedSet set; + + public ReversedShortOrderedSet(ShortOrderedSet set) { + this.set = set; + } + + @Override + public ReversedShortOrderedSet copy() { throw new UnsupportedOperationException(); } + @Override + public ShortBidirectionalIterator iterator(short fromElement) { + return set.iterator(fromElement); + } + + @Override + public ShortBidirectionalIterator iterator() { + return set.reverseIterator(); + } + + @Override + public ShortBidirectionalIterator reverseIterator() { + return set.iterator(); + } + + @Override + public boolean remove(short o) { + return set.remove(o); + } + + @Override + public boolean add(short o) { + return set.add(o); + } + + @Override + public boolean addAndMoveToFirst(short o) { + return set.addAndMoveToLast(o); + } + + @Override + public boolean addAndMoveToLast(short o) { + return set.addAndMoveToFirst(o); + } + + @Override + public boolean moveToFirst(short o) { + return set.moveToLast(o); + } + + @Override + public boolean moveToLast(short o) { + return set.moveToFirst(o); + } + + @Override + public short getFirstShort() { + return set.getLastShort(); + } + + @Override + public short removeFirstShort() { + return set.removeLastShort(); + } + + @Override + public short getLastShort() { + return set.getFirstShort(); + } + + @Override + public short removeLastShort() { + return set.removeFirstShort(); + } + + @Override + public ShortOrderedSet reversed() { + return set; + } + + @Override + public int size() { + return set.size(); + } + } } \ No newline at end of file diff --git a/src/main/java/speiger/src/collections/shorts/sets/ImmutableShortOpenHashSet.java b/src/main/java/speiger/src/collections/shorts/sets/ImmutableShortOpenHashSet.java index 151df83..8fea192 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ImmutableShortOpenHashSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ImmutableShortOpenHashSet.java @@ -259,22 +259,22 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short } @Override - public short firstShort() { + public short getFirstShort() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { + public short getLastShort() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } @Override public boolean remove(Object o) { throw new UnsupportedOperationException(); } @@ -412,7 +412,12 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short @Override public ShortListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -476,16 +481,20 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short } private class SetIterator implements ShortListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(short from) { + this.forward = true; if(from == (short)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -514,48 +523,60 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -564,8 +585,8 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short @Override public short previousShort() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -573,12 +594,22 @@ public class ImmutableShortOpenHashSet extends AbstractShortSet implements Short @Override public short nextShort() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortArraySet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortArraySet.java index 4929e8c..4d2fff0 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortArraySet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortArraySet.java @@ -186,13 +186,13 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet } @Override - public short firstShort() { + public short getFirstShort() { if(size == 0) throw new NoSuchElementException(); return data[0]; } @Override - public short lastShort() { + public short getLastShort() { if(size == 0) throw new NoSuchElementException(); return data[size - 1]; } @@ -283,7 +283,7 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet } @Override - public short pollFirstShort() { + public short removeFirstShort() { if(size == 0) throw new NoSuchElementException(); short result = data[0]; System.arraycopy(data, 1, data, 0, --size); @@ -291,7 +291,7 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet } @Override - public short pollLastShort() { + public short removeLastShort() { if(size == 0) throw new NoSuchElementException(); size--; return data[size]; @@ -414,13 +414,18 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet @Override public ShortBidirectionalIterator iterator() { - return new SetIterator(0); + return new SetIterator(true, 0); + } + + @Override + public ShortBidirectionalIterator reverseIterator() { + return new SetIterator(false, size); } @Override public ShortBidirectionalIterator iterator(short fromElement) { int index = findIndex(fromElement); - if(index != -1) return new SetIterator(index); + if(index != -1) return new SetIterator(true, index); throw new NoSuchElementException(); } @@ -471,45 +476,57 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet } private class SetIterator implements ShortListIterator { + boolean forward; int index; int lastReturned = -1; - public SetIterator(int index) { + public SetIterator(boolean forward, int index) { + this.forward = forward; this.index = index; } @Override public boolean hasNext() { - return index < size(); + return forward ? index < size() : index > 0; } @Override public short nextShort() { if(!hasNext()) throw new NoSuchElementException(); - lastReturned = index; - return data[index++]; + if(forward) { + lastReturned = index; + return data[index++]; + } + index--; + return data[(lastReturned = index)]; } @Override public boolean hasPrevious() { - return index > 0; + return forward ? index > 0 : index < size(); } @Override public short previousShort() { if(!hasPrevious()) throw new NoSuchElementException(); - --index; - return data[(lastReturned = index)]; + if(forward) { + index--; + return data[(lastReturned = index)]; + } + lastReturned = index; + return data[index++]; } @Override public int nextIndex() { - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { - return index-1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -529,15 +546,23 @@ public class ShortArraySet extends AbstractShortSet implements ShortOrderedSet @Override public int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveForward(amount) : moveBackwards(amount); + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + return forward ? moveBackwards(amount) : moveForward(amount); + } + + private int moveForward(int amount) { int steps = Math.min(amount, size() - index); index += steps; if(steps > 0) lastReturned = Math.min(index-1, size()-1); return steps; } - @Override - public int back(int amount) { - if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + private int moveBackwards(int amount) { int steps = Math.min(amount, index); index -= steps; if(steps > 0) lastReturned = Math.min(index, size()-1); diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenCustomHashSet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenCustomHashSet.java index 42092a8..30add5a 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenCustomHashSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenCustomHashSet.java @@ -270,7 +270,7 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public boolean moveToFirst(short o) { - if(isEmpty() || strategy.equals(firstShort(), o)) return false; + if(isEmpty() || strategy.equals(getFirstShort(), o)) return false; if(strategy.equals(o, (short)0)) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -292,7 +292,7 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public boolean moveToLast(short o) { - if(isEmpty() || strategy.equals(lastShort(), o)) return false; + if(isEmpty() || strategy.equals(getLastShort(), o)) return false; if(strategy.equals(o, (short)0)) { if(containsNull) { moveToLastIndex(nullIndex); @@ -349,13 +349,13 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme } @Override - public short firstShort() { + public short getFirstShort() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public short pollFirstShort() { + public short removeFirstShort() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -371,13 +371,13 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme } @Override - public short lastShort() { + public short getLastShort() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public short pollLastShort() { + public short removeLastShort() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -659,7 +659,12 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public ShortListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -684,16 +689,20 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme } private class SetIterator implements ShortListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(short from) { + this.forward = true; if(strategy.equals(from, (short)0)) { if(containsNull) { next = (int) links[nullIndex]; @@ -722,48 +731,60 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -812,8 +833,8 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public short previousShort() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -821,12 +842,22 @@ public class ShortLinkedOpenCustomHashSet extends ShortOpenCustomHashSet impleme @Override public short nextShort() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenHashSet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenHashSet.java index f0a076f..bf1a1b7 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenHashSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortLinkedOpenHashSet.java @@ -239,7 +239,7 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public boolean moveToFirst(short o) { - if(isEmpty() || firstShort() == o) return false; + if(isEmpty() || getFirstShort() == o) return false; if(o == (short)0) { if(containsNull) { moveToFirstIndex(nullIndex); @@ -261,7 +261,7 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public boolean moveToLast(short o) { - if(isEmpty() || lastShort() == o) return false; + if(isEmpty() || getLastShort() == o) return false; if(o == (short)0) { if(containsNull) { moveToLastIndex(nullIndex); @@ -318,13 +318,13 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd } @Override - public short firstShort() { + public short getFirstShort() { if(size == 0) throw new NoSuchElementException(); return keys[firstIndex]; } @Override - public short pollFirstShort() { + public short removeFirstShort() { if(size == 0) throw new NoSuchElementException(); int pos = firstIndex; onNodeRemoved(pos); @@ -340,13 +340,13 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd } @Override - public short lastShort() { + public short getLastShort() { if(size == 0) throw new NoSuchElementException(); return keys[lastIndex]; } @Override - public short pollLastShort() { + public short removeLastShort() { if(size == 0) throw new NoSuchElementException(); int pos = lastIndex; onNodeRemoved(pos); @@ -628,7 +628,12 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public ShortListIterator iterator() { - return new SetIterator(); + return new SetIterator(true); + } + + @Override + public ShortListIterator reverseIterator() { + return new SetIterator(false); } @Override @@ -653,16 +658,20 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd } private class SetIterator implements ShortListIterator { + boolean forward; int previous = -1; int next = -1; int current = -1; - int index = 0; + int index = -1; - SetIterator() { - next = firstIndex; + SetIterator(boolean start) { + this.forward = start; + if(start) next = firstIndex; + else previous = lastIndex; } SetIterator(short from) { + this.forward = true; if(from == (short)0) { if(containsNull) { next = (int) links[nullIndex]; @@ -691,48 +700,60 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public int skip(int amount) { - int result = 0; - while(next != -1 && result != amount) { - current = previous = next; - next = (int)(links[current]); - result++; - } + int result = forward ? moveForward(amount) : moveBackwards(amount); if(index >= 0) index+=result; return result; } @Override public int back(int amount) { + int result = forward ? moveBackwards(amount) : moveForward(amount); + if(index >= 0) index-=result; + return result; + } + + private int moveForward(int amount) { + int result = 0; + while(next != -1 && result != amount) { + current = previous = next; + next = (int)(links[current]); + result++; + } + return result; + } + + private int moveBackwards(int amount) { int result = 0; while(previous != -1 && result != amount) { current = next = previous; previous = (int)(links[current] >> 32); result++; } - if(index >= 0) index-=result; return result; } @Override public boolean hasNext() { - return next != -1; + return (forward ? next : previous) != -1; } @Override public boolean hasPrevious() { - return previous != -1; + return (forward ? previous : next) != -1; } @Override public int nextIndex() { ensureIndexKnown(); - return index; + if(forward) return index; + return size - index; } @Override public int previousIndex() { ensureIndexKnown(); - return index - 1; + if(forward) return index-1; + return (size - index)-1; } @Override @@ -781,8 +802,8 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public short previousShort() { if(!hasPrevious()) throw new NoSuchElementException(); - current = next = previous; - previous = (int)(links[current] >> 32); + if(forward) moveBackwards(); + else moveForwards(); if(index >= 0) index--; return keys[current]; } @@ -790,12 +811,22 @@ public class ShortLinkedOpenHashSet extends ShortOpenHashSet implements ShortOrd @Override public short nextShort() { if(!hasNext()) throw new NoSuchElementException(); - current = previous = next; - next = (int)(links[current]); + if(forward) moveForwards(); + else moveBackwards(); if(index >= 0) index++; return keys[current]; } + private void moveBackwards() { + current = next = previous; + previous = (int)(links[current] >> 32); + } + + private void moveForwards() { + current = previous = next; + next = (int)(links[current]); + } + private void ensureIndexKnown() { if(index == -1) { if(previous == -1) { diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortNavigableSet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortNavigableSet.java index 3f96311..18ddbea 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortNavigableSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortNavigableSet.java @@ -4,8 +4,8 @@ import java.util.NavigableSet; import speiger.src.collections.shorts.collections.ShortBidirectionalIterator; import speiger.src.collections.shorts.collections.ShortSplititerator; -import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.shorts.utils.ShortSplititerators; +import speiger.src.collections.shorts.utils.ShortSets; /** * A Type Specific Navigable Set interface with a couple helper methods diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortOrderedSet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortOrderedSet.java index ef6a76a..11edaed 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortOrderedSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortOrderedSet.java @@ -2,8 +2,9 @@ package speiger.src.collections.shorts.sets; import speiger.src.collections.shorts.collections.ShortBidirectionalIterator; import speiger.src.collections.shorts.collections.ShortSplititerator; -import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.shorts.utils.ShortSplititerators; +import speiger.src.collections.shorts.sets.AbstractShortSet.ReversedShortOrderedSet; +import speiger.src.collections.shorts.utils.ShortSets; /** * A Special Set Interface giving Access to some really usefull functions @@ -49,6 +50,7 @@ public interface ShortOrderedSet extends ShortSet @Override public ShortBidirectionalIterator iterator(); + public ShortBidirectionalIterator reverseIterator(); /** * A type Specific Iterator starting from a given key @@ -69,23 +71,26 @@ public interface ShortOrderedSet extends ShortSet * A method to get the first element in the set * @return first element in the set */ - public short firstShort(); + public short getFirstShort(); /** * A method to get and remove the first element in the set * @return first element in the set */ - public short pollFirstShort(); + public short removeFirstShort(); /** * A method to get the last element in the set * @return last element in the set */ - public short lastShort(); + public short getLastShort(); /** * A method to get and remove the last element in the set * @return last element in the set */ - public short pollLastShort(); + public short removeLastShort(); + + public default ShortOrderedSet reversed() { return new ReversedShortOrderedSet(this); } + /** * Creates a Wrapped OrderedSet that is Synchronized * @return a new OrderedSet that is synchronized diff --git a/src/main/java/speiger/src/collections/shorts/sets/ShortSet.java b/src/main/java/speiger/src/collections/shorts/sets/ShortSet.java index cfff503..1a0a197 100644 --- a/src/main/java/speiger/src/collections/shorts/sets/ShortSet.java +++ b/src/main/java/speiger/src/collections/shorts/sets/ShortSet.java @@ -5,8 +5,8 @@ import java.util.Set; import speiger.src.collections.shorts.collections.ShortCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.collections.ShortSplititerator; -import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.shorts.utils.ShortSplititerators; +import speiger.src.collections.shorts.utils.ShortSets; /** diff --git a/src/main/java/speiger/src/collections/shorts/utils/ShortCollections.java b/src/main/java/speiger/src/collections/shorts/utils/ShortCollections.java index cbb66d3..25906ae 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/ShortCollections.java +++ b/src/main/java/speiger/src/collections/shorts/utils/ShortCollections.java @@ -12,6 +12,7 @@ import java.util.function.Consumer; import speiger.src.collections.shorts.collections.AbstractShortCollection; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.collections.ShortIterator; import speiger.src.collections.shorts.functions.ShortComparator; import speiger.src.collections.objects.utils.ObjectArrays; @@ -51,6 +52,34 @@ public class ShortCollections return c instanceof UnmodifiableCollection ? c : new UnmodifiableCollection(c); } + /** + * Returns a Immutable Ordered Collection instance based on the instance given. + * @param c that should be made immutable/unmodifiable + * @return a unmodifiable Ordered collection wrapper. If the Collection already a unmodifiable wrapper then it just returns itself. + */ + public static ShortOrderedCollection unmodifiable(ShortOrderedCollection c) { + return c instanceof UnmodifiableOrderedCollection ? c : new UnmodifiableOrderedCollection(c); + } + + /** + * Returns a synchronized ordered Collection instance based on the instance given. + * @param c that should be synchronized + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ShortOrderedCollection synchronize(ShortOrderedCollection c) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(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. + * @return a synchronized ordered collection wrapper. If the Collection already a synchronized wrapper then it just returns itself. + */ + public static ShortOrderedCollection synchronize(ShortOrderedCollection c, Object mutex) { + return c instanceof SynchronizedOrderedCollection ? c : new SynchronizedOrderedCollection(c, mutex); + } + /** * Returns a synchronized Collection instance based on the instance given. * @param c that should be synchronized @@ -584,6 +613,37 @@ public class ShortCollections @Override public SingletonCollection copy() { return new SingletonCollection(element); } } + /** + * Synchronized Ordered Collection Wrapper for the synchronizedCollection function + */ + public static class SynchronizedOrderedCollection extends SynchronizedCollection implements ShortOrderedCollection { + ShortOrderedCollection c; + + SynchronizedOrderedCollection(ShortOrderedCollection c, Object mutex) { + super(c, mutex); + this.c = c; + } + + SynchronizedOrderedCollection(ShortOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ShortOrderedCollection reversed() { return ShortCollections.synchronize(c.reversed(), mutex); } + @Override + public void addFirst(short e) { synchronized(mutex) { this.c.addFirst(e); } } + @Override + public void addLast(short e) { synchronized(mutex) { this.c.addLast(e); } } + @Override + public short getFirstShort() { synchronized(mutex) { return this.c.getFirstShort(); } } + @Override + public short removeFirstShort() { synchronized(mutex) { return this.c.removeFirstShort(); } } + @Override + public short getLastShort() { synchronized(mutex) { return this.c.getLastShort(); } } + @Override + public short removeLastShort() { synchronized(mutex) { return this.c.removeLastShort(); } } + } /** * Synchronized Collection Wrapper for the synchronizedCollection function @@ -705,6 +765,33 @@ public class ShortCollections public int count(ShortPredicate filter) { synchronized(mutex) { return c.count(filter); } } } + /** + * Unmodifyable Ordered Collection Wrapper for the unmodifyableCollection method + */ + public static class UnmodifiableOrderedCollection extends UnmodifiableCollection implements ShortOrderedCollection { + ShortOrderedCollection c; + + UnmodifiableOrderedCollection(ShortOrderedCollection c) { + super(c); + this.c = c; + } + + @Override + public ShortOrderedCollection reversed() { return ShortCollections.unmodifiable(c.reversed()); } + @Override + public void addFirst(short e) { throw new UnsupportedOperationException(); } + @Override + public void addLast(short e) { throw new UnsupportedOperationException(); } + @Override + public short getFirstShort() { return c.getFirstShort(); } + @Override + public short removeFirstShort() { throw new UnsupportedOperationException(); } + @Override + public short getLastShort() { return c.getLastShort(); } + @Override + public short removeLastShort() { throw new UnsupportedOperationException(); } + } + /** * Unmodifyable Collection Wrapper for the unmodifyableCollection method */ diff --git a/src/main/java/speiger/src/collections/shorts/utils/ShortIterators.java b/src/main/java/speiger/src/collections/shorts/utils/ShortIterators.java index 8a227ed..c212622 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/ShortIterators.java +++ b/src/main/java/speiger/src/collections/shorts/utils/ShortIterators.java @@ -34,7 +34,7 @@ public class ShortIterators * Returns a Immutable EmptyIterator instance that is automatically casted. * @return an empty iterator */ - public static EmptyIterator empty() { + public static ShortListIterator empty() { return EMPTY; } @@ -303,7 +303,7 @@ public class ShortIterators * @param a the array that should be wrapped * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(short... a) { + public static ShortIterator wrap(short... a) { return wrap(a, 0, a.length); } @@ -314,7 +314,7 @@ public class ShortIterators * @param end the index that should be ended. * @return a Iterator that is wrapping a array. */ - public static ArrayIterator wrap(short[] a, int start, int end) { + public static ShortIterator wrap(short[] a, int start, int end) { return new ArrayIterator(a, start, end); } diff --git a/src/main/java/speiger/src/collections/shorts/utils/ShortLists.java b/src/main/java/speiger/src/collections/shorts/utils/ShortLists.java index ecc4438..d656ccf 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/ShortLists.java +++ b/src/main/java/speiger/src/collections/shorts/utils/ShortLists.java @@ -30,7 +30,7 @@ public class ShortLists * Returns a Immutable EmptyList instance that is automatically casted. * @return an empty list */ - public static EmptyList empty() { + public static ShortList empty() { return EMPTY; } diff --git a/src/main/java/speiger/src/collections/shorts/utils/ShortSets.java b/src/main/java/speiger/src/collections/shorts/utils/ShortSets.java index 3d15406..a243453 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/ShortSets.java +++ b/src/main/java/speiger/src/collections/shorts/utils/ShortSets.java @@ -312,17 +312,19 @@ public class ShortSets @Override public ShortBidirectionalIterator iterator() { return ShortIterators.unmodifiable(s.iterator()); } @Override + public ShortBidirectionalIterator reverseIterator() { return ShortIterators.unmodifiable(s.reverseIterator()); } + @Override public ShortBidirectionalIterator iterator(short fromElement) { return ShortIterators.unmodifiable(s.iterator(fromElement)); } @Override public ShortOrderedSet copy() { return s.copy(); } @Override - public short firstShort() { return s.firstShort(); } + public short getFirstShort() { return s.getFirstShort(); } @Override - public short pollFirstShort() { throw new UnsupportedOperationException(); } + public short removeFirstShort() { throw new UnsupportedOperationException(); } @Override - public short lastShort() { return s.lastShort(); } + public short getLastShort() { return s.getLastShort(); } @Override - public short pollLastShort() { throw new UnsupportedOperationException(); } + public short removeLastShort() { throw new UnsupportedOperationException(); } } private static class UnmodifiableSortedSet extends UnmodifiableSet implements ShortSortedSet @@ -583,17 +585,19 @@ public class ShortSets @Override public ShortBidirectionalIterator iterator() { synchronized(mutex) { return s.iterator(); } } @Override + public ShortBidirectionalIterator reverseIterator() { synchronized(mutex) { return s.reverseIterator(); } } + @Override public ShortBidirectionalIterator iterator(short fromElement) { synchronized(mutex) { return s.iterator(fromElement); } } @Override public ShortOrderedSet copy() { synchronized(mutex) { return s.copy(); } } @Override - public short firstShort() { synchronized(mutex) { return s.firstShort(); } } + public short getFirstShort() { synchronized(mutex) { return s.getFirstShort(); } } @Override - public short pollFirstShort() { synchronized(mutex) { return s.pollFirstShort(); } } + public short removeFirstShort() { synchronized(mutex) { return s.removeFirstShort(); } } @Override - public short lastShort() { synchronized(mutex) { return s.lastShort(); } } + public short getLastShort() { synchronized(mutex) { return s.getLastShort(); } } @Override - public short pollLastShort() { synchronized(mutex) { return s.pollLastShort(); } } + public short removeLastShort() { synchronized(mutex) { return s.removeLastShort(); } } } private static class SynchronizedTrimSet extends SynchronizedSet implements ITrimmable diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2BooleanMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2BooleanMaps.java index 16e46f3..d69af44 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2BooleanMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2BooleanMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.booleans.collections.BooleanCollection; +import speiger.src.collections.booleans.collections.BooleanOrderedCollection; import speiger.src.collections.booleans.functions.function.BooleanBooleanUnaryOperator; import speiger.src.collections.booleans.functions.BooleanSupplier; import speiger.src.collections.booleans.utils.BooleanCollections; @@ -431,6 +432,10 @@ public class Short2BooleanMaps @Override public boolean putAndMoveToLast(short key, boolean value) { throw new UnsupportedOperationException(); } @Override + public boolean putFirst(short key, boolean value) { throw new UnsupportedOperationException(); } + @Override + public boolean putLast(short key, boolean value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -451,13 +456,25 @@ public class Short2BooleanMaps @Override public boolean lastBooleanValue() { return map.lastBooleanValue(); } @Override + public Short2BooleanMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2BooleanMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2BooleanMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2BooleanMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2BooleanOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.unmodifiable(map.values()); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet short2BooleanEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2BooleanEntrySet()); @@ -605,15 +622,17 @@ public class Short2BooleanMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2BooleanMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2BooleanMap.Entry first() { return set.first(); } + public Short2BooleanMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2BooleanMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2BooleanMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2BooleanMap.Entry last() { return set.last(); } + public Short2BooleanMap.Entry getLast() { return set.getLast(); } @Override - public Short2BooleanMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2BooleanMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -782,6 +801,10 @@ public class Short2BooleanMaps @Override public boolean putAndMoveToLast(short key, boolean value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public boolean putFirst(short key, boolean value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public boolean putLast(short key, boolean value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -802,13 +825,25 @@ public class Short2BooleanMaps @Override public boolean lastBooleanValue() { synchronized(mutex) { return map.lastBooleanValue(); } } @Override + public Short2BooleanMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2BooleanMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2BooleanMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2BooleanMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2BooleanOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public BooleanOrderedCollection values() { + if(values == null) values = BooleanCollections.synchronize(map.values(), mutex); + return (BooleanOrderedCollection)values; + } @Override public ObjectOrderedSet short2BooleanEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2BooleanEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ByteMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ByteMaps.java index 62405e4..e94e144 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ByteMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ByteMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.bytes.collections.ByteCollection; +import speiger.src.collections.bytes.collections.ByteOrderedCollection; import speiger.src.collections.bytes.functions.function.ByteByteUnaryOperator; import speiger.src.collections.bytes.functions.ByteSupplier; import speiger.src.collections.bytes.utils.ByteCollections; @@ -439,6 +440,10 @@ public class Short2ByteMaps @Override public byte putAndMoveToLast(short key, byte value) { throw new UnsupportedOperationException(); } @Override + public byte putFirst(short key, byte value) { throw new UnsupportedOperationException(); } + @Override + public byte putLast(short key, byte value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2ByteMaps @Override public byte lastByteValue() { return map.lastByteValue(); } @Override + public Short2ByteMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2ByteMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2ByteMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ByteMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2ByteOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.unmodifiable(map.values()); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet short2ByteEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2ByteEntrySet()); @@ -617,15 +634,17 @@ public class Short2ByteMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2ByteMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2ByteMap.Entry first() { return set.first(); } + public Short2ByteMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2ByteMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ByteMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ByteMap.Entry last() { return set.last(); } + public Short2ByteMap.Entry getLast() { return set.getLast(); } @Override - public Short2ByteMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ByteMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2ByteMaps @Override public byte putAndMoveToLast(short key, byte value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public byte putFirst(short key, byte value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public byte putLast(short key, byte value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2ByteMaps @Override public byte lastByteValue() { synchronized(mutex) { return map.lastByteValue(); } } @Override + public Short2ByteMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2ByteMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2ByteMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2ByteMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2ByteOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public ByteOrderedCollection values() { + if(values == null) values = ByteCollections.synchronize(map.values(), mutex); + return (ByteOrderedCollection)values; + } @Override public ObjectOrderedSet short2ByteEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2ByteEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2CharMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2CharMaps.java index 2437a1f..98c91ed 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2CharMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2CharMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.chars.collections.CharCollection; +import speiger.src.collections.chars.collections.CharOrderedCollection; import speiger.src.collections.chars.functions.function.CharCharUnaryOperator; import speiger.src.collections.chars.functions.CharSupplier; import speiger.src.collections.chars.utils.CharCollections; @@ -439,6 +440,10 @@ public class Short2CharMaps @Override public char putAndMoveToLast(short key, char value) { throw new UnsupportedOperationException(); } @Override + public char putFirst(short key, char value) { throw new UnsupportedOperationException(); } + @Override + public char putLast(short key, char value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2CharMaps @Override public char lastCharValue() { return map.lastCharValue(); } @Override + public Short2CharMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2CharMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2CharMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2CharMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2CharOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.unmodifiable(map.values()); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet short2CharEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2CharEntrySet()); @@ -617,15 +634,17 @@ public class Short2CharMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2CharMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2CharMap.Entry first() { return set.first(); } + public Short2CharMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2CharMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2CharMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2CharMap.Entry last() { return set.last(); } + public Short2CharMap.Entry getLast() { return set.getLast(); } @Override - public Short2CharMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2CharMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2CharMaps @Override public char putAndMoveToLast(short key, char value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public char putFirst(short key, char value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public char putLast(short key, char value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2CharMaps @Override public char lastCharValue() { synchronized(mutex) { return map.lastCharValue(); } } @Override + public Short2CharMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2CharMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2CharMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2CharMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2CharOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public CharOrderedCollection values() { + if(values == null) values = CharCollections.synchronize(map.values(), mutex); + return (CharOrderedCollection)values; + } @Override public ObjectOrderedSet short2CharEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2CharEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2DoubleMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2DoubleMaps.java index 283580f..e99f55f 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2DoubleMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2DoubleMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.doubles.collections.DoubleCollection; +import speiger.src.collections.doubles.collections.DoubleOrderedCollection; import speiger.src.collections.doubles.functions.function.DoubleDoubleUnaryOperator; import speiger.src.collections.doubles.functions.DoubleSupplier; import speiger.src.collections.doubles.utils.DoubleCollections; @@ -439,6 +440,10 @@ public class Short2DoubleMaps @Override public double putAndMoveToLast(short key, double value) { throw new UnsupportedOperationException(); } @Override + public double putFirst(short key, double value) { throw new UnsupportedOperationException(); } + @Override + public double putLast(short key, double value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2DoubleMaps @Override public double lastDoubleValue() { return map.lastDoubleValue(); } @Override + public Short2DoubleMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2DoubleMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2DoubleMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2DoubleMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2DoubleOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.unmodifiable(map.values()); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet short2DoubleEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2DoubleEntrySet()); @@ -617,15 +634,17 @@ public class Short2DoubleMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2DoubleMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2DoubleMap.Entry first() { return set.first(); } + public Short2DoubleMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2DoubleMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2DoubleMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2DoubleMap.Entry last() { return set.last(); } + public Short2DoubleMap.Entry getLast() { return set.getLast(); } @Override - public Short2DoubleMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2DoubleMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2DoubleMaps @Override public double putAndMoveToLast(short key, double value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public double putFirst(short key, double value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public double putLast(short key, double value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2DoubleMaps @Override public double lastDoubleValue() { synchronized(mutex) { return map.lastDoubleValue(); } } @Override + public Short2DoubleMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2DoubleMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2DoubleMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2DoubleMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2DoubleOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public DoubleOrderedCollection values() { + if(values == null) values = DoubleCollections.synchronize(map.values(), mutex); + return (DoubleOrderedCollection)values; + } @Override public ObjectOrderedSet short2DoubleEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2DoubleEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2FloatMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2FloatMaps.java index b2c6a8b..e278ffb 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2FloatMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2FloatMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.floats.collections.FloatCollection; +import speiger.src.collections.floats.collections.FloatOrderedCollection; import speiger.src.collections.floats.functions.function.FloatFloatUnaryOperator; import speiger.src.collections.floats.functions.FloatSupplier; import speiger.src.collections.floats.utils.FloatCollections; @@ -439,6 +440,10 @@ public class Short2FloatMaps @Override public float putAndMoveToLast(short key, float value) { throw new UnsupportedOperationException(); } @Override + public float putFirst(short key, float value) { throw new UnsupportedOperationException(); } + @Override + public float putLast(short key, float value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2FloatMaps @Override public float lastFloatValue() { return map.lastFloatValue(); } @Override + public Short2FloatMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2FloatMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2FloatMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2FloatMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2FloatOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.unmodifiable(map.values()); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet short2FloatEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2FloatEntrySet()); @@ -617,15 +634,17 @@ public class Short2FloatMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2FloatMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2FloatMap.Entry first() { return set.first(); } + public Short2FloatMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2FloatMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2FloatMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2FloatMap.Entry last() { return set.last(); } + public Short2FloatMap.Entry getLast() { return set.getLast(); } @Override - public Short2FloatMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2FloatMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2FloatMaps @Override public float putAndMoveToLast(short key, float value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public float putFirst(short key, float value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public float putLast(short key, float value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2FloatMaps @Override public float lastFloatValue() { synchronized(mutex) { return map.lastFloatValue(); } } @Override + public Short2FloatMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2FloatMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2FloatMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2FloatMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2FloatOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public FloatOrderedCollection values() { + if(values == null) values = FloatCollections.synchronize(map.values(), mutex); + return (FloatOrderedCollection)values; + } @Override public ObjectOrderedSet short2FloatEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2FloatEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2IntMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2IntMaps.java index 95c7d24..055e52f 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2IntMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2IntMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.ints.collections.IntCollection; +import speiger.src.collections.ints.collections.IntOrderedCollection; import speiger.src.collections.ints.functions.function.IntIntUnaryOperator; import speiger.src.collections.ints.functions.IntSupplier; import speiger.src.collections.ints.utils.IntCollections; @@ -439,6 +440,10 @@ public class Short2IntMaps @Override public int putAndMoveToLast(short key, int value) { throw new UnsupportedOperationException(); } @Override + public int putFirst(short key, int value) { throw new UnsupportedOperationException(); } + @Override + public int putLast(short key, int value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2IntMaps @Override public int lastIntValue() { return map.lastIntValue(); } @Override + public Short2IntMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2IntMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2IntMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2IntMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2IntOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.unmodifiable(map.values()); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet short2IntEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2IntEntrySet()); @@ -617,15 +634,17 @@ public class Short2IntMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2IntMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2IntMap.Entry first() { return set.first(); } + public Short2IntMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2IntMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2IntMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2IntMap.Entry last() { return set.last(); } + public Short2IntMap.Entry getLast() { return set.getLast(); } @Override - public Short2IntMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2IntMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2IntMaps @Override public int putAndMoveToLast(short key, int value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public int putFirst(short key, int value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public int putLast(short key, int value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2IntMaps @Override public int lastIntValue() { synchronized(mutex) { return map.lastIntValue(); } } @Override + public Short2IntMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2IntMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2IntMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2IntMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2IntOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public IntOrderedCollection values() { + if(values == null) values = IntCollections.synchronize(map.values(), mutex); + return (IntOrderedCollection)values; + } @Override public ObjectOrderedSet short2IntEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2IntEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2LongMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2LongMaps.java index f0e8323..b785ef4 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2LongMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2LongMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.longs.collections.LongCollection; +import speiger.src.collections.longs.collections.LongOrderedCollection; import speiger.src.collections.longs.functions.function.LongLongUnaryOperator; import speiger.src.collections.longs.functions.LongSupplier; import speiger.src.collections.longs.utils.LongCollections; @@ -439,6 +440,10 @@ public class Short2LongMaps @Override public long putAndMoveToLast(short key, long value) { throw new UnsupportedOperationException(); } @Override + public long putFirst(short key, long value) { throw new UnsupportedOperationException(); } + @Override + public long putLast(short key, long value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2LongMaps @Override public long lastLongValue() { return map.lastLongValue(); } @Override + public Short2LongMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2LongMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2LongMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2LongMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2LongOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.unmodifiable(map.values()); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet short2LongEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2LongEntrySet()); @@ -617,15 +634,17 @@ public class Short2LongMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2LongMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2LongMap.Entry first() { return set.first(); } + public Short2LongMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2LongMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2LongMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2LongMap.Entry last() { return set.last(); } + public Short2LongMap.Entry getLast() { return set.getLast(); } @Override - public Short2LongMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2LongMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -794,6 +813,10 @@ public class Short2LongMaps @Override public long putAndMoveToLast(short key, long value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public long putFirst(short key, long value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public long putLast(short key, long value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -814,13 +837,25 @@ public class Short2LongMaps @Override public long lastLongValue() { synchronized(mutex) { return map.lastLongValue(); } } @Override + public Short2LongMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2LongMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2LongMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2LongMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2LongOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public LongOrderedCollection values() { + if(values == null) values = LongCollections.synchronize(map.values(), mutex); + return (LongOrderedCollection)values; + } @Override public ObjectOrderedSet short2LongEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2LongEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ObjectMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ObjectMaps.java index 694b1fb..2a85e4d 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ObjectMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ObjectMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.objects.collections.ObjectCollection; +import speiger.src.collections.objects.collections.ObjectOrderedCollection; import speiger.src.collections.objects.functions.function.ObjectObjectUnaryOperator; import speiger.src.collections.objects.functions.ObjectSupplier; import speiger.src.collections.objects.utils.ObjectCollections; @@ -439,6 +440,10 @@ public class Short2ObjectMaps @Override public V putAndMoveToLast(short key, V value) { throw new UnsupportedOperationException(); } @Override + public V putFirst(short key, V value) { throw new UnsupportedOperationException(); } + @Override + public V putLast(short key, V value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -459,13 +464,25 @@ public class Short2ObjectMaps @Override public V lastValue() { return map.lastValue(); } @Override + public Short2ObjectMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2ObjectMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2ObjectMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ObjectMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2ObjectOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.unmodifiable(map.values()); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> short2ObjectEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet<>(map.short2ObjectEntrySet()); @@ -608,15 +625,17 @@ public class Short2ObjectMaps @Override public ObjectBidirectionalIterator> iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator> reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator> iterator(Short2ObjectMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2ObjectMap.Entry first() { return set.first(); } + public Short2ObjectMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2ObjectMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ObjectMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ObjectMap.Entry last() { return set.last(); } + public Short2ObjectMap.Entry getLast() { return set.getLast(); } @Override - public Short2ObjectMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ObjectMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -788,6 +807,10 @@ public class Short2ObjectMaps @Override public V putAndMoveToLast(short key, V value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public V putFirst(short key, V value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public V putLast(short key, V value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -808,13 +831,25 @@ public class Short2ObjectMaps @Override public V lastValue() { synchronized(mutex) { return map.lastValue(); } } @Override + public Short2ObjectMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2ObjectMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2ObjectMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2ObjectMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2ObjectOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public ObjectOrderedCollection values() { + if(values == null) values = ObjectCollections.synchronize(map.values(), mutex); + return (ObjectOrderedCollection)values; + } @Override public ObjectOrderedSet> short2ObjectEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2ObjectEntrySet(), mutex); diff --git a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ShortMaps.java b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ShortMaps.java index 07b0954..4996041 100644 --- a/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ShortMaps.java +++ b/src/main/java/speiger/src/collections/shorts/utils/maps/Short2ShortMaps.java @@ -29,6 +29,7 @@ import speiger.src.collections.shorts.sets.ShortOrderedSet; import speiger.src.collections.shorts.sets.ShortSet; import speiger.src.collections.shorts.utils.ShortSets; import speiger.src.collections.shorts.collections.ShortCollection; +import speiger.src.collections.shorts.collections.ShortOrderedCollection; import speiger.src.collections.shorts.functions.ShortSupplier; import speiger.src.collections.shorts.utils.ShortCollections; @@ -438,6 +439,10 @@ public class Short2ShortMaps @Override public short putAndMoveToLast(short key, short value) { throw new UnsupportedOperationException(); } @Override + public short putFirst(short key, short value) { throw new UnsupportedOperationException(); } + @Override + public short putLast(short key, short value) { throw new UnsupportedOperationException(); } + @Override public boolean moveToFirst(short key) { throw new UnsupportedOperationException(); } @Override public boolean moveToLast(short key) { throw new UnsupportedOperationException(); } @@ -458,13 +463,25 @@ public class Short2ShortMaps @Override public short lastShortValue() { return map.lastShortValue(); } @Override + public Short2ShortMap.Entry firstEntry() { return map.firstEntry(); } + @Override + public Short2ShortMap.Entry lastEntry() { return map.lastEntry(); } + @Override + public Short2ShortMap.Entry pollFirstEntry() { throw new UnsupportedOperationException(); } + @Override + public Short2ShortMap.Entry pollLastEntry() { throw new UnsupportedOperationException(); } + @Override public Short2ShortOrderedMap copy() { return map.copy(); } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.unmodifiable(map.keySet()); return (ShortOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.unmodifiable(map.values()); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet short2ShortEntrySet() { if(entrySet == null) entrySet = new UnmodifyableOrderedEntrySet(map.short2ShortEntrySet()); @@ -616,15 +633,17 @@ public class Short2ShortMaps @Override public ObjectBidirectionalIterator iterator() { return ObjectIterators.unmodifiable(set.iterator()); } @Override + public ObjectBidirectionalIterator reverseIterator() { return ObjectIterators.unmodifiable(set.reverseIterator()); } + @Override public ObjectBidirectionalIterator iterator(Short2ShortMap.Entry fromElement) { return ObjectIterators.unmodifiable(set.iterator(fromElement)); } @Override - public Short2ShortMap.Entry first() { return set.first(); } + public Short2ShortMap.Entry getFirst() { return set.getFirst(); } @Override - public Short2ShortMap.Entry pollFirst() { throw new UnsupportedOperationException(); } + public Short2ShortMap.Entry removeFirst() { throw new UnsupportedOperationException(); } @Override - public Short2ShortMap.Entry last() { return set.last(); } + public Short2ShortMap.Entry getLast() { return set.getLast(); } @Override - public Short2ShortMap.Entry pollLast() { throw new UnsupportedOperationException(); } + public Short2ShortMap.Entry removeLast() { throw new UnsupportedOperationException(); } } /** @@ -793,6 +812,10 @@ public class Short2ShortMaps @Override public short putAndMoveToLast(short key, short value) { synchronized(mutex) { return map.putAndMoveToLast(key, value); } } @Override + public short putFirst(short key, short value) { synchronized(mutex) { return map.putFirst(key, value); } } + @Override + public short putLast(short key, short value) { synchronized(mutex) { return map.putLast(key, value); } } + @Override public boolean moveToFirst(short key) { synchronized(mutex) { return map.moveToFirst(key); } } @Override public boolean moveToLast(short key) { synchronized(mutex) { return map.moveToLast(key); } } @@ -813,13 +836,25 @@ public class Short2ShortMaps @Override public short lastShortValue() { synchronized(mutex) { return map.lastShortValue(); } } @Override + public Short2ShortMap.Entry firstEntry() { synchronized(mutex) { return map.firstEntry(); } } + @Override + public Short2ShortMap.Entry lastEntry() { synchronized(mutex) { return map.lastEntry(); } } + @Override + public Short2ShortMap.Entry pollFirstEntry() { synchronized(mutex) { return map.pollFirstEntry(); } } + @Override + public Short2ShortMap.Entry pollLastEntry() { synchronized(mutex) { return map.pollLastEntry(); } } + @Override public Short2ShortOrderedMap copy() { synchronized(mutex) { return map.copy(); } } @Override public ShortOrderedSet keySet() { if(keys == null) keys = ShortSets.synchronize(map.keySet(), mutex); return (ShortOrderedSet)keys; } - + @Override + public ShortOrderedCollection values() { + if(values == null) values = ShortCollections.synchronize(map.values(), mutex); + return (ShortOrderedCollection)values; + } @Override public ObjectOrderedSet short2ShortEntrySet() { if(entrySet == null) entrySet = ObjectSets.synchronize(map.short2ShortEntrySet(), mutex); diff --git a/src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java b/src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java index d20947a..1aa9f12 100644 --- a/src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java +++ b/src/test/java/speiger/src/collections/ints/base/BaseIntOrderedSetTest.java @@ -40,8 +40,8 @@ public abstract class BaseIntOrderedSetTest extends BaseIntCollectionTest public void peekTest() { if(getValidOrderedSetTests().contains(OrderedSetTest.PEEK)) { IntOrderedSet set = create(TEST_ARRAY); - Assert.assertEquals(set.firstInt(), 0); - Assert.assertEquals(set.lastInt(), 99); + Assert.assertEquals(set.getFirstInt(), 0); + Assert.assertEquals(set.getLastInt(), 99); } } @@ -51,12 +51,12 @@ public abstract class BaseIntOrderedSetTest extends BaseIntCollectionTest IntOrderedSet set = create(TEST_ARRAY); for(int i = 0;i<100;i++) { - Assert.assertEquals(i, set.pollFirstInt()); + Assert.assertEquals(i, set.removeFirstInt()); } set = create(TEST_ARRAY); for(int i = 99;i>=0;i--) { - Assert.assertEquals(i, set.pollLastInt()); + Assert.assertEquals(i, set.removeLastInt()); } } } diff --git a/src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java b/src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java index 5f3290f..b1e5546 100644 --- a/src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java +++ b/src/test/java/speiger/src/collections/ints/base/BaseIntPriorityQueueTest.java @@ -113,7 +113,6 @@ public abstract class BaseIntPriorityQueueTest extends BaseIntIterableTest } @Test - @SuppressWarnings("deprecation") public void testToArray() { if(getValidPriorityQueueTests().contains(PriorityQueueTest.TO_ARRAY)) { IntPriorityQueue queue = create(EMPTY_ARRAY);