From 5cc4f35407c9ba1080aa274f48fc28b430971baf Mon Sep 17 00:00:00 2001 From: Speiger Date: Mon, 16 Nov 2020 02:55:33 +0100 Subject: [PATCH] New Content patch getting big progress on base and progress on lists. -Changed: Build Task no longer Sync's because it is 9x slower and a File Builder never collides with another File Builder. -Added: getEquals() function for faster compare builders. -Changed: getNonClassType to getNonFileType() -Added: New Rule to the Rule Sheet. -Added: Regex Helper so recursion is supported -Added: FunctionMapper that supports more then 1 argument. -Changed: Injection & FunctionMapper support recursion- -Added: Loads of Variables to the GlobalVariables as they were added for templates. -Added: AbstractCollection, AbstractList, List, ListIterator, BidirectionalIterator, Arrays and ArrayList template. --- RuleSheet.md | 1 + .../src/builder/example/ClassType.java | 15 +- .../src/builder/example/GlobalVariables.java | 63 +++- .../src/builder/example/TestBuilder.java | 1 + .../src/builder/mappers/ArgumentMapper.java | 65 ++++ .../src/builder/mappers/InjectMapper.java | 21 +- .../speiger/src/builder/misc/RegexUtil.java | 68 ++++ .../src/builder/processor/BuildTask.java | 2 +- .../utils/BidirectionalIterator.java | 17 + .../collections/AbstractCollection.template | 53 +++- .../BidirectionalIterator.template | 28 ++ .../templates/collections/Collection.template | 12 +- .../templates/collections/Iterator.template | 8 +- .../templates/lists/AbstractList.template | 296 ++++++++++++++++++ .../templates/lists/ArrayList.template | 147 +++++++++ .../collections/templates/lists/List.template | 90 ++++++ .../templates/lists/ListIterator.template | 38 +++ .../templates/utils/Arrays.template | 20 ++ .../templates/utils/Iterators.template | 79 +++++ 19 files changed, 995 insertions(+), 29 deletions(-) create mode 100644 src/main/java/speiger/src/builder/mappers/ArgumentMapper.java create mode 100644 src/main/java/speiger/src/builder/misc/RegexUtil.java create mode 100644 src/main/java/speiger/src/collections/utils/BidirectionalIterator.java create mode 100644 src/main/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template create mode 100644 src/main/resources/speiger/assets/collections/templates/lists/AbstractList.template create mode 100644 src/main/resources/speiger/assets/collections/templates/lists/ArrayList.template create mode 100644 src/main/resources/speiger/assets/collections/templates/lists/List.template create mode 100644 src/main/resources/speiger/assets/collections/templates/lists/ListIterator.template create mode 100644 src/main/resources/speiger/assets/collections/templates/utils/Arrays.template create mode 100644 src/main/resources/speiger/assets/collections/templates/utils/Iterators.template diff --git a/RuleSheet.md b/RuleSheet.md index ed9befb4..48742295 100644 --- a/RuleSheet.md +++ b/RuleSheet.md @@ -12,5 +12,6 @@ Some Base Rules: - Function overloads should be avoided. They are only causing problems. - If a primitive function would cause a overload then a rename should try to add a shortened primitive name in it. If that destroys the naming flow then a cut version name. If that does not work a new rule has to be made up. Example: "get -> getInt" while "removeIf => removeIfInt" does not work so we default to "removeIf => remIf". - If a function would break the java interface rules (ArrayList.trimToSize) a dedicated interface should be created for it. +- If a #if is wrapping a function the #if always starts after a empty new line and the #endif always has a empty new line before itself. That way empty lines match up no matter the type Rules can be added or altered, but should only be so if there is a real reason to be present. \ No newline at end of file diff --git a/src/main/java/speiger/src/builder/example/ClassType.java b/src/main/java/speiger/src/builder/example/ClassType.java index 3e147dd1..7203255f 100644 --- a/src/main/java/speiger/src/builder/example/ClassType.java +++ b/src/main/java/speiger/src/builder/example/ClassType.java @@ -37,9 +37,9 @@ public enum ClassType return classType; } - public String getNonClassType() + public String getNonFileType() { - return this == OBJECT ? "" : classType; + return this == OBJECT ? "" : fileType; } public String getFileType() @@ -67,6 +67,17 @@ public enum ClassType return this == BYTE || this == SHORT || this == CHAR || this == FLOAT; } + public String getEquals() + { + switch(this) + { + case DOUBLE: return "Double.doubleToLongBits(%1$s) == Double.doubleToLongBits(%2$s)"; + case FLOAT: return "Float.floatToIntBits(%1$s) == Float.floatToIntBits(%2$s)"; + case OBJECT: return "Objects.equals(%1$s, %2$s)"; + default: return "%1$s == %2$s"; + } + } + public ClassType getCustomJDKType() { switch(this) diff --git a/src/main/java/speiger/src/builder/example/GlobalVariables.java b/src/main/java/speiger/src/builder/example/GlobalVariables.java index 26e1c32d..5e05ffb6 100644 --- a/src/main/java/speiger/src/builder/example/GlobalVariables.java +++ b/src/main/java/speiger/src/builder/example/GlobalVariables.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Set; import java.util.function.UnaryOperator; +import speiger.src.builder.mappers.ArgumentMapper; import speiger.src.builder.mappers.InjectMapper; import speiger.src.builder.mappers.SimpleMapper; import speiger.src.builder.processor.TemplateProcess; @@ -28,15 +29,23 @@ public class GlobalVariables addSimpleMapper("CLASS_TYPE", type.getClassType()); addSimpleMapper("KEY_TYPE", type.getKeyType()); addSimpleMapper(" KEY_GENERIC_TYPE", type == ClassType.OBJECT ? "<"+type.getKeyType()+">" : ""); + addSimpleMapper(" GENERIC_BRACES", type == ClassType.OBJECT ? " <"+type.getKeyType()+">" : ""); + addSimpleMapper("BRACES", type == ClassType.OBJECT ? "<>" : ""); if(type.needsCustomJDKType()) { addSimpleMapper("JAVA_TYPE", type.getCustomJDKType().getKeyType()); addSimpleMapper("SANITY_CAST", "castTo"+type.getFileType()); } + return this; + } + + public GlobalVariables createHelperVariables() + { + addArgumentMapper("EQUALS_KEY_TYPE", type == ClassType.OBJECT ? "Objects.equals(%1$s, %2$s)" : "Objects.equals(KEY_TO_OBJ(%1$s), %2$s)").removeBraces(); + addArgumentMapper("EQUALS", type.getEquals()).removeBraces(); addSimpleMapper("KEY_TO_OBJ", type.getClassType()+".valueOf"); - addInjectMapper("OBJ_TO_KEY(\\([^)]+\\)|\\S)", "%s."+type.getKeyType()+"Value()").removeBraces(); - addInjectMapper("CLASS_TO_KEY(\\([^)]+\\)|\\S)", "(("+type.getClassType()+")%s)."+type.getKeyType()+"Value()").removeBraces(); - + addInjectMapper("OBJ_TO_KEY", type == ClassType.OBJECT ? "%s" : "%s."+type.getKeyType()+"Value()").removeBraces(); + addInjectMapper("CLASS_TO_KEY", "(("+type.getClassType()+")%s)."+type.getKeyType()+"Value()").removeBraces(); return this; } @@ -44,17 +53,31 @@ public class GlobalVariables { addSimpleMapper("JAVA_PREDICATE", type.isPrimitiveBlocking() ? "" : type.getCustomJDKType().getFileType()+"Predicate"); addSimpleMapper("JAVA_CONSUMER", type.isPrimitiveBlocking() ? "" : "java.util.function."+type.getCustomJDKType().getFileType()+"Consumer"); - addSimpleMapper("CONSUMER", type.getFileType()+"Consumer"); - addSimpleMapper("ITERATOR", type.getFileType()+"Iterator"); - addSimpleMapper("ITERABLE", type.getFileType()+"Iterable"); - addSimpleMapper("ABSTRACT_COLLECTION", type.getFileType()+"AbstractCollection"); - addSimpleMapper("COLLECTION", type.getFileType()+"Collection"); + addClassMapper("CONSUMER", "Consumer"); + addClassMapper("ITERATORS", "Iterators"); + addClassMapper("BI_ITERATOR", "BidirectionalIterator"); + addClassMapper("LIST_ITERATOR", "ListIterator"); + addClassMapper("ITERATOR", "Iterator"); + addClassMapper("ITERABLE", "Iterable"); + addClassMapper("ABSTRACT_COLLECTION", "AbstractCollection"); + addClassMapper("COLLECTION", "Collection"); + addClassMapper("ARRAYS", "Arrays"); + addClassMapper("ABSTRACT_LIST", "AbstractList"); + addClassMapper("LIST_ITER", "ListIter"); + addClassMapper("SUB_LIST", "SubList"); + addClassMapper("ARRAY_LIST", "ArrayList"); + addClassMapper("LIST", "List"); return this; } public GlobalVariables createFunctions() { - addSimpleMapper("NEXT()", "next"+type.getNonClassType()+"()"); + addFunctionMapper("NEXT", "next"); + addSimpleMapper("TO_ARRAY", "to"+type.getNonFileType()+"Array"); + addFunctionMapper("GET_KEY", "get"); + addFunctionMapper("REMOVE_KEY", "rem"); + addFunctionMapper("REMOVE", "remove"); + addFunctionMapper("PREVIOUS", "previous"); return this; } @@ -86,6 +109,16 @@ public class GlobalVariables return type; } + private void addClassMapper(String pattern, String replacement) + { + operators.add(new SimpleMapper(pattern, type.getFileType()+replacement)); + } + + private void addFunctionMapper(String pattern, String replacement) + { + operators.add(new SimpleMapper(pattern, replacement+type.getNonFileType())); + } + private void addSimpleMapper(String pattern, String replacement) { operators.add(new SimpleMapper(pattern, replacement)); @@ -98,6 +131,18 @@ public class GlobalVariables return mapper; } + private ArgumentMapper addArgumentMapper(String pattern, String replacement) + { + return addArgumentMapper(pattern, replacement, ", "); + } + + private ArgumentMapper addArgumentMapper(String pattern, String replacement, String splitter) + { + ArgumentMapper mapper = new ArgumentMapper(pattern, replacement, splitter); + operators.add(mapper); + return mapper; + } + class PathBuilder implements UnaryOperator { String before; diff --git a/src/main/java/speiger/src/builder/example/TestBuilder.java b/src/main/java/speiger/src/builder/example/TestBuilder.java index 5a522b5f..39fe25a2 100644 --- a/src/main/java/speiger/src/builder/example/TestBuilder.java +++ b/src/main/java/speiger/src/builder/example/TestBuilder.java @@ -45,6 +45,7 @@ public class TestBuilder extends TemplateProcessor { GlobalVariables type = new GlobalVariables(clzType); type.createFlags(); + type.createHelperVariables(); type.createVariables(); type.createClassTypes(); type.createFunctions(); diff --git a/src/main/java/speiger/src/builder/mappers/ArgumentMapper.java b/src/main/java/speiger/src/builder/mappers/ArgumentMapper.java new file mode 100644 index 00000000..6f6e6207 --- /dev/null +++ b/src/main/java/speiger/src/builder/mappers/ArgumentMapper.java @@ -0,0 +1,65 @@ +package speiger.src.builder.mappers; + +import java.util.function.UnaryOperator; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import speiger.src.builder.misc.RegexUtil; + +public class ArgumentMapper implements UnaryOperator +{ + Pattern pattern; + String replacement; + String argumentBreaker; + String braces = "()"; + boolean removeBraces; + + public ArgumentMapper(String pattern, String replacement, String argumentBreaker) + { + this.pattern = Pattern.compile(pattern); + this.replacement = replacement; + this.argumentBreaker = argumentBreaker; + } + + public ArgumentMapper setBraceType(String s) + { + if(s.length() != 2) throw new IllegalStateException("Start and End char only"); + braces = s; + return this; + } + + public ArgumentMapper removeBraces() + { + removeBraces = true; + return this; + } + + @Override + public String apply(String t) + { + Matcher matcher = pattern.matcher(t); + if(matcher.find()) + { + StringBuffer buffer = new StringBuffer(); + do + { + String text = RegexUtil.searchUntil(t, matcher.end()-1, braces.charAt(0), braces.charAt(1)); + if(!text.isEmpty()) + { + RegexUtil.skip(matcher.appendReplacement(buffer, ""), text.length()); + buffer.append(String.format(replacement, (Object[])getString(text).split(argumentBreaker))); + } + } + while(matcher.find()); + matcher.appendTail(buffer); + return buffer.toString(); + } + return t; + } + + protected String getString(String s) + { + return removeBraces ? s.substring(1, s.length() - 1) : s; + } + +} diff --git a/src/main/java/speiger/src/builder/mappers/InjectMapper.java b/src/main/java/speiger/src/builder/mappers/InjectMapper.java index 315838fe..b80ff224 100644 --- a/src/main/java/speiger/src/builder/mappers/InjectMapper.java +++ b/src/main/java/speiger/src/builder/mappers/InjectMapper.java @@ -4,10 +4,13 @@ import java.util.function.UnaryOperator; import java.util.regex.Matcher; import java.util.regex.Pattern; +import speiger.src.builder.misc.RegexUtil; + public class InjectMapper implements UnaryOperator { Pattern pattern; String replacement; + String braces = "()"; boolean removeBraces; public InjectMapper(String pattern, String replacement) @@ -16,6 +19,13 @@ public class InjectMapper implements UnaryOperator this.replacement = replacement; } + public InjectMapper setBraceType(String s) + { + if(s.length() != 2) throw new IllegalStateException("Start and End char only"); + braces = s; + return this; + } + public InjectMapper removeBraces() { removeBraces = true; @@ -29,7 +39,14 @@ public class InjectMapper implements UnaryOperator if(matcher.find()) { StringBuffer buffer = new StringBuffer(); - do { matcher.appendReplacement(buffer, String.format(replacement, getString(matcher.group(1)))); + do + { + String text = RegexUtil.searchUntil(t, matcher.end()-1, braces.charAt(0), braces.charAt(1)); + if(!text.isEmpty()) + { + RegexUtil.skip(matcher.appendReplacement(buffer, ""), text.length()); + buffer.append(String.format(replacement, getString(text))); + } } while (matcher.find()); matcher.appendTail(buffer); return buffer.toString(); @@ -37,7 +54,7 @@ public class InjectMapper implements UnaryOperator return t; } - private String getString(String s) + protected String getString(String s) { return removeBraces ? s.substring(1, s.length() - 1) : s; } diff --git a/src/main/java/speiger/src/builder/misc/RegexUtil.java b/src/main/java/speiger/src/builder/misc/RegexUtil.java new file mode 100644 index 00000000..5a21c66e --- /dev/null +++ b/src/main/java/speiger/src/builder/misc/RegexUtil.java @@ -0,0 +1,68 @@ +package speiger.src.builder.misc; + +import java.lang.reflect.Field; +import java.util.regex.Matcher; + +public class RegexUtil +{ + static Field LAST_POS; + + public static Matcher skip(Matcher matcher, int amount) + { + try + { + LAST_POS.setInt(matcher, LAST_POS.getInt(matcher) + amount); + } + catch(Exception e) + { + e.printStackTrace(); + } + return matcher; + } + + public static String searchUntil(String text, int startIndex, char increase, char decrease) + { + if(text.charAt(startIndex + 1) != increase) + { + return ""; + } + int inc = 0; + StringBuilder builder = new StringBuilder(); + for(int i = startIndex + 1;i extends Iterator +{ + public E previous(); + + public boolean hasPrevious(); + + public default int back(int amount) { + if(amount < 0) throw new IllegalStateException("Can't go forward"); + int i = 0; + for(;i implements COLLECTION KEY_GENERIC_TYPE { @Override public abstract ITERATOR KEY_GENERIC_TYPE iterator(); -#if !TYPE_OBJECT +#if !TYPE_OBJECT @Override @Deprecated public boolean add(CLASS_TYPE e) { return COLLECTION.super.add(e); } @@ -31,6 +37,30 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle return false; } + @Override + public boolean containsAll(Collection c) + { + return c instanceof COLLECTION ? containsAll((COLLECTION)c) : super.containsAll(c); + } + + @Override + public boolean addAll(Collection c) + { + return c instanceof COLLECTION ? addAll((COLLECTION)c) : super.addAll(c); + } + + @Override + public boolean removeAll(Collection c) + { + return c instanceof COLLECTION ? removeAll((COLLECTION)c) : super.removeAll(c); + } + + @Override + public boolean retainAll(Collection c) + { + return c instanceof COLLECTION ? retainAll((COLLECTION)c) : super.retainAll(c); + } + @Override public boolean containsAll(COLLECTION c) { for(KEY_TYPE e : c) @@ -51,6 +81,17 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle @Deprecated public boolean remove(Object e) { return COLLECTION.super.remove(e); } + @Override + public boolean REMOVE_KEY(KEY_TYPE e) { + for(ITERATOR iter = iterator();iter.hasNext();) { + if(EQUALS(iter.NEXT(), e)) { + iter.remove(); + return true; + } + } + return false; + } + @Override public boolean removeAll(COLLECTION c) { boolean modified = false; @@ -74,5 +115,15 @@ public abstract class ABSTRACT_COLLECTION KEY_GENERIC_TYPE extends AbstractColle } return modified; } + + public KEY_TYPE[] TO_ARRAY() { + return TO_ARRAY(new KEY_TYPE[size()]); + } + + public KEY_TYPE[] TO_ARRAY(KEY_TYPE[] a) { + if(a == null || a.length < size()) a = new KEY_TYPE[size()]; + ITERATORS.unwrap(a, iterator()); + return a; + } #endif } \ No newline at end of file diff --git a/src/main/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template b/src/main/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template new file mode 100644 index 00000000..ffeafef6 --- /dev/null +++ b/src/main/resources/speiger/assets/collections/templates/collections/BidirectionalIterator.template @@ -0,0 +1,28 @@ +package speiger.src.collections.PACKAGE.collections; + +#if !TYPE_OBJECT +import speiger.src.collections.objects.collections.ObjectBidirectionalIterator; + +public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE, ObjectBidirectionalIterator +#else +import speiger.src.collections.utils.BidirectionalIterator; + +public interface BI_ITERATOR KEY_GENERIC_TYPE extends ITERATOR KEY_GENERIC_TYPE, BidirectionalIterator +#endif +{ + public KEY_TYPE PREVIOUS(); + +#if !TYPE_OBJECT + @Override + @Deprecated + public default CLASS_TYPE previous() { + return KEY_TO_OBJ(PREVIOUS()); + } + + @Override + default int skip(int amount) + { + return ITERATOR.super.skip(amount); + } +#endif +} \ No newline at end of file diff --git a/src/main/resources/speiger/assets/collections/templates/collections/Collection.template b/src/main/resources/speiger/assets/collections/templates/collections/Collection.template index 1a9e1f2b..12abd48d 100644 --- a/src/main/resources/speiger/assets/collections/templates/collections/Collection.template +++ b/src/main/resources/speiger/assets/collections/templates/collections/Collection.template @@ -19,7 +19,7 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection, ITE public boolean containsAny(COLLECTION c); - public boolean remove(KEY_TYPE o); + public boolean REMOVE_KEY(KEY_TYPE o); public boolean removeAll(COLLECTION c); @@ -43,7 +43,7 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection, ITE return removed; } -#endif +#endif @Override @Deprecated public default boolean add(CLASS_TYPE o) { return add(OBJ_TO_KEY(o)); } @@ -56,14 +56,6 @@ public interface COLLECTION KEY_GENERIC_TYPE extends Collection, ITE @Deprecated public default boolean remove(Object o) { return o != null && remove(CLASS_TO_KEY(o)); } - @Override - @Deprecated - public K[] toArray(K[] a); - - @Override - @Deprecated - public Object[] toArray(); - #endif @Override public ITERATOR KEY_GENERIC_TYPE iterator(); diff --git a/src/main/resources/speiger/assets/collections/templates/collections/Iterator.template b/src/main/resources/speiger/assets/collections/templates/collections/Iterator.template index e90c25d2..f8a3cf98 100644 --- a/src/main/resources/speiger/assets/collections/templates/collections/Iterator.template +++ b/src/main/resources/speiger/assets/collections/templates/collections/Iterator.template @@ -16,7 +16,7 @@ public interface ITERATOR KEY_GENERIC_TYPE extends Iterator @Deprecated @Override - public default CLASS_TYPE next() { return KEY_TO_OBJ(next()); } + public default CLASS_TYPE next() { return KEY_TO_OBJ(NEXT()); } public default void forEachRemaining(CONSUMER action) { Objects.requireNonNull(action); @@ -33,8 +33,8 @@ public interface ITERATOR KEY_GENERIC_TYPE extends Iterator #endif default int skip(int amount) { if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); - int temp = amount; - for(;amount > 0 && hasNext();NEXT(), amount--); - return temp - amount; + int i = 0; + for(;i toIndex(" + to + ")"); + this.l = l; + offset = from; + size = to - from; + } + + @Override + public void add(int index, KEY_TYPE e) { + checkAddRange(index); + l.add(index+offset, e); + size++; + } + +#if !TYPE_OBJECT + @Override + public void add(int index, CLASS_TYPE element) { + add(index, OBJ_TO_KEY(element)); + } + +#endif + @Override + public boolean addAll(int index, Collection c) { + checkAddRange(index); + int size = c.size(); + if(size == 0) return false; + l.addAll(index + offset, l); + offset += size; + return true; + } + +#if !TYPE_OBJECT + @Override + public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c) { + checkAddRange(index); + int size = c.size(); + if(size == 0) return false; + l.addAll(index + offset, l); + offset += size; + return true; + } + +#endif + @Override + public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) { + checkAddRange(index); + int size = c.size(); + if(size == 0) return false; + l.addAll(index + offset, l); + offset += size; + return true; + } + + @Override + public KEY_TYPE GET_KEY(int index) { + checkRange(index); + return l.GET_KEY(index + offset); + } + + @Override + public KEY_TYPE set(int index, KEY_TYPE e) { + checkRange(index); + return l.set(index + offset, e); + } + + @Override + public KEY_TYPE REMOVE(int index) { + checkRange(index); + size--; + return l.REMOVE(index + offset); + } + + @Override + public int size() { + return size; + } + + private void checkRange(int index) { + if (index < 0 || index >= size) + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + + private void checkAddRange(int index) { + if (index < 0 || index > size) + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + } + + private class LIST_ITER implements LIST_ITERATOR KEY_GENERIC_TYPE { + int index; + int lastReturned = -1; + + LIST_ITER(int index) { + this.index = index; + } + + @Override + public boolean hasNext() { + return index < size(); + } + + @Override + public KEY_TYPE NEXT() { + return GET_KEY(index++); + } + + @Override + public boolean hasPrevious() { + return index > 0; + } + + @Override + public KEY_TYPE PREVIOUS() { + return GET_KEY(index--); + } + + @Override + public int nextIndex() { + return index; + } + + @Override + public int previousIndex() { + return index-1; + } + + @Override + public void remove() { + if(lastReturned == -1) + throw new IllegalStateException(); + ABSTRACT_LIST.this.REMOVE(lastReturned); + if(lastReturned < index) + index--; + lastReturned = -1; + } + + @Override + public void set(KEY_TYPE e) { + if(lastReturned == -1) + throw new IllegalStateException(); + ABSTRACT_LIST.this.set(lastReturned, e); + } + + @Override + public void add(KEY_TYPE e) { + if(lastReturned == -1) + throw new IllegalStateException(); + ABSTRACT_LIST.this.add(index++, e); + lastReturned = -1; + } + + @Override + public int skip(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + int steps = Math.min(amount, (size() - 1) - index); + index += steps; + return steps; + } + + @Override + public int back(int amount) { + if(amount < 0) throw new IllegalStateException("Negative Numbers are not allowed"); + int steps = Math.min(amount, index); + index -= steps; + return steps; + } + } +} \ No newline at end of file diff --git a/src/main/resources/speiger/assets/collections/templates/lists/ArrayList.template b/src/main/resources/speiger/assets/collections/templates/lists/ArrayList.template new file mode 100644 index 00000000..50b64f37 --- /dev/null +++ b/src/main/resources/speiger/assets/collections/templates/lists/ArrayList.template @@ -0,0 +1,147 @@ +package speiger.src.collections.PACKAGE.lists; + +import java.util.Collection; +import java.util.Iterator; + +#if !TYPE_OBJECT +import speiger.src.collections.PACKAGE.collections.COLLECTION; +import speiger.src.collections.PACKAGE.collections.ITERATOR; +#endif + +public class ARRAY_LIST KEY_GENERIC_TYPE extends ABSTRACT_LIST KEY_GENERIC_TYPE +{ + transient KEY_TYPE[] data; + private int size = 0; + + public ARRAY_LIST(int size) + { +#if TYPE_OBJECT + data = (KEY_TYPE[])new Object[size]; +#else + data = new KEY_TYPE[size]; +#endif + } + + @Override + public void add(int index, CLASS_TYPE element) + { + checkAddRange(index); + ensureCapacity(size + 1); + if(index != size) System.arraycopy(data, index, data, index+1, size - index); + data[index] = OBJ_TO_KEY(element); + size++; + } + + @Override + public boolean add(KEY_TYPE e) + { + ensureCapacity(size + 1); + data[size++] = e; + return true; + } + +#if !TYPE_OBJECT + @Override + public void add(int index, KEY_TYPE e) + { + checkAddRange(index); + ensureCapacity(size + 1); + if(index != size) System.arraycopy(data, index, data, index+1, size - index); + data[index] = e; + size++; + } + +#endif + @Override + public boolean addAll(int index, Collection c) + { +#if !TYPE_OBJECT + if(c instanceof COLLECTION) return addAll((COLLECTION)c); +#endif + int add = c.size(); + if(add <= 0) return false; + ensureCapacity(size + add); + if(index != size) System.arraycopy(data, index, data, index+add, size - index); + size+=add; + Iterator iter = c.iterator(); + while(add != 0) data[index++] = OBJ_TO_KEY(iter.next()); + return true; + } + +#if !TYPE_OBJECT + @Override + public boolean addAll(int index, COLLECTION KEY_GENERIC_TYPE c) + { + if(c instanceof LIST) return addAll((LIST)c); + int add = c.size(); + if(add <= 0) return false; + ensureCapacity(size + add); + if(index != size) System.arraycopy(data, index, data, index+add, size - index); + size+=add; + ITERATOR KEY_GENERIC_TYPE iter = c.iterator(); + while(add != 0) data[index++] = iter.NEXT(); + return true; + } + +#endif + + @Override + public boolean addAll(int index, LIST KEY_GENERIC_TYPE c) + { + return false; + } + + @Override + public KEY_TYPE GET_KEY(int index) + { + if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is not in lists size (" + size + ")"); + return data[index]; + } + + @Override + public KEY_TYPE set(int index, KEY_TYPE e) + { + if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is not in lists size (" + size + ")"); + KEY_TYPE old = data[index]; + data[index] = e; + return old; + } + + @Override + public KEY_TYPE REMOVE(int index) + { + if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is not in lists size (" + size + ")"); + KEY_TYPE old = data[index]; + if(index != size) System.arraycopy(data, index+1, data, index, size - index); +#if TYPE_OBJECT + data[size] = null; +#endif + size--; + return old; + } + + @Override + public int size() + { + return size; + } + + @Override + public void clear() + { +#if TYPE_OBJECT + for(int i = 0;i +{ +#if !TYPE_OBJECT + public boolean add(KEY_TYPE e); + + public void add(int index, KEY_TYPE e); + + public boolean addAll(int index, COLLECTION c); + +#endif + public boolean addAll(LIST KEY_GENERIC_TYPE c); + + public boolean addAll(int index, LIST KEY_GENERIC_TYPE c); + +#if !TYPE_OBJECT + public KEY_TYPE GET_KEY(int index); + + public KEY_TYPE set(int index, KEY_TYPE e); + + public KEY_TYPE REMOVE(int index); + + public int indexOf(KEY_TYPE e); + + public int lastIndexOf(KEY_TYPE e); + +#endif + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(); + + @Override + public LIST_ITERATOR KEY_GENERIC_TYPE listIterator(int index); + + @Override + public LIST KEY_GENERIC_TYPE subList(int from, int to); + +#if !TYPE_OBJECT + @Override + @Deprecated + public default boolean add(CLASS_TYPE e) { + return COLLECTION.super.add(e); + } + + @Override + @Deprecated + public default CLASS_TYPE get(int index) { + return KEY_TO_OBJ(GET_KEY(index)); + } + + @Override + @Deprecated + public default CLASS_TYPE set(int index, CLASS_TYPE e) { + return KEY_TO_OBJ(set(index, OBJ_TO_KEY(e))); + } + + @Override + @Deprecated + public default int indexOf(Object o) { + return indexOf(CLASS_TO_KEY(o)); + } + + @Override + @Deprecated + public default int lastIndexOf(Object o) { + return indexOf(CLASS_TO_KEY(o)); + } + + @Override + @Deprecated + public default boolean contains(Object o) { + return COLLECTION.super.contains(o); + } + + @Override + @Deprecated + public default boolean remove(Object o) { + return COLLECTION.super.remove(o); + } + + @Override + @Deprecated + public default CLASS_TYPE remove(int index) { + return KEY_TO_OBJ(REMOVE(index)); + } +#endif +} \ No newline at end of file diff --git a/src/main/resources/speiger/assets/collections/templates/lists/ListIterator.template b/src/main/resources/speiger/assets/collections/templates/lists/ListIterator.template new file mode 100644 index 00000000..620b1968 --- /dev/null +++ b/src/main/resources/speiger/assets/collections/templates/lists/ListIterator.template @@ -0,0 +1,38 @@ +package speiger.src.collections.PACKAGE.lists; + +import java.util.ListIterator; + +import speiger.src.collections.PACKAGE.collections.BI_ITERATOR; + +public interface LIST_ITERATOR KEY_GENERIC_TYPE extends ListIterator, BI_ITERATOR KEY_GENERIC_TYPE +{ +#if !TYPE_OBJECT + public void set(KEY_TYPE e); + + public void add(KEY_TYPE e); + + @Override + @Deprecated + public default CLASS_TYPE previous() { + return BI_ITERATOR.super.previous(); + } + + @Override + @Deprecated + public default CLASS_TYPE next() { + return BI_ITERATOR.super.next(); + } + + @Override + @Deprecated + public default void set(CLASS_TYPE e) { + set(OBJ_TO_KEY(e)); + } + + @Override + @Deprecated + public default void add(CLASS_TYPE e) { + add(OBJ_TO_KEY(e)); + } +#endif +} \ No newline at end of file diff --git a/src/main/resources/speiger/assets/collections/templates/utils/Arrays.template b/src/main/resources/speiger/assets/collections/templates/utils/Arrays.template new file mode 100644 index 00000000..a3b49172 --- /dev/null +++ b/src/main/resources/speiger/assets/collections/templates/utils/Arrays.template @@ -0,0 +1,20 @@ +package speiger.src.collections.PACKAGE.utils; + +public class ARRAYS +{ +#if !TYPE_OBJECT + public static CLASS_TYPE[] wrap(KEY_TYPE[] a) { + CLASS_TYPE[] result = new CLASS_TYPE[a.length]; + for(int i = 0,m=a.length;i= a.length) throw new IllegalStateException("largest array index exceeds array size"); + int index = 0; + for(;index= a.length) throw new IllegalStateException("largest array index exceeds array size"); + int index = 0; + for(;index