From 1a29d40fced0c55455c6d8d1eddd947eaa8827cc Mon Sep 17 00:00:00 2001 From: Willem Date: Tue, 3 Feb 2026 11:08:20 +0100 Subject: [PATCH] JPP: Small fixes in collection2 to think abount X0 naming --- .../src/test/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BabelTest.java | 14 +-- .../ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactoryTest.java | 3 +- .../ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ArrayLadderOpen.java | 26 +---- .../main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java | 29 ++++- .../java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/LadderOpen.java | 24 ++++- .../src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Yarn.java | 90 +++++++++++----- .../main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java | 102 ++++++++---------- .../java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/Rope.java | 19 ++-- .../ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeIterable.java | 8 +- .../ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadder.java | 26 ++--- .../ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadderOpen.java | 77 ++++++------- 11 files changed, 229 insertions(+), 189 deletions(-) diff --git a/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BabelTest.java b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BabelTest.java index 43fd649..2667597 100644 --- a/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BabelTest.java +++ b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BabelTest.java @@ -37,14 +37,10 @@ import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAu @DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天") public class BabelTest { - // ᒢᣘᐧᐧ // jppa = nether + land + collection2 - // ᒢᣘᐧᣟ // jppb = klass + number - // ᒢᣘᣟᐧ // jppc = ~jpp-base - // ᒢᣘᣟᣟ // jppd = jmx + other-optional - //ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ - //ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ.ᔆᔿᓑᣗᣘ - //ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᙆᓫᣗᒄᑊᣕᣔᒻ - //ᒢᣘᐧᐧ.ᒻᣔᣕᒄ. + // ᒢᣘᐧᐧ // jpp0 = nether + land + collections2 + // ᒢᣘᐧᣟ // jpp1 = klass + number + // ᒢᣘᣟᐧ // jpp2 = ~jpp-base + // ᒢᣘᣟᣟ // jpp3 = jmx + other-optional //ᒢᐩᐩ.ᓫᣕᐪᓫᣗ.ᔆᔿᓑᣗᣘ //ᒢᐩᐩ.ᑊᑉᒻᣔᔆᔆ.ᔆʸᔆᐪᓫᔿ.ᣔᒃᣔᒼᓑᔆ //ᒢᐩᐩ.ᑊᑉᒻᣔᔆᔆ.ᔆʸᔆᐪᓫᔿ.ᣔᒃᣔᒼᓑᔆ @@ -66,7 +62,7 @@ public class BabelTest { // - real enum terminator set is from FC18 (FCFlameNumberGram.java) // - bone based terminators up to PIG size 2304 (after 99% of JPP code comes from nether generate on use) // - virtual terminator from nether chord group selector slug path is 2^18 bit pie part values - // - extended virtual pie slice terminators of nether is thus 2 times 2^18 (so max gun/etc leaf depth is 6 Q slugs) TODO: zerdinal => upgrade 2 long for 36 bit window size + // - extended virtual pie slice terminators of nether is thus 2 times 2^18 (so max gun/etc leaf depth is 6 Q slugs) // ^^ for java3, in java4 100% of runtime+libs is generated per method, so only code which is used. // ᒢᐩᐩ.ᣕᓑᔿᒃᓫᣗ.ᙆᓫᣗᒄᑊᣕᣔᒻ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.ᕐᓑᣕᔆ // ᒢᐩᐩ.ᣕᓑᔿᒃᓫᣗ.ᒻᓫᕐᐤ.ᒢᓫᑊᐣᑊ (+JediTempleBase256InfinityZero redo generics-tree from LegoᐧBrickᐧTapeᐧRecorderᐧχ3 ?) diff --git a/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactoryTest.java b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactoryTest.java index 09d9290..37bb628 100644 --- a/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactoryTest.java +++ b/nx01-jpp-base/src/test/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactoryTest.java @@ -84,7 +84,8 @@ public class NumberMatrixFactoryTest { // size: 20 result: 2432902008176640000 // size: 21 result: -4249290049419214848 (long overflow) // collections2: size/zerdinal/offset/etc is signed long (63 bit) - // collections2D: try for 18 up to 2304 bit++ + // collections2T: ZerdinalX144 extend ZerdinalX0 + // collections2P: ZerdinalX2304 extend ZerdinalX0 for (int i = 5; i < 20; i++) { int[] rankFirst = calculateLehmerFromRank(0, i); long amount = calculateTotalPermutations(rankFirst); diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ArrayLadderOpen.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ArrayLadderOpen.java index 7f8ad98..7ef0b72 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ArrayLadderOpen.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ArrayLadderOpen.java @@ -29,12 +29,12 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ; import java.util.ArrayList; import java.util.Arrays; -import java.util.Comparator; import java.util.List; import java.util.Spliterator; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator; +import java.util.stream.Collector; import java.util.stream.Stream; import ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ.Rope; @@ -102,11 +102,6 @@ public class ArrayLadderOpen implements LadderOpen,RopeIterable { return data.set((int) index, element); } - @Override - public void sort(Comparator c) { // TODO: add default impl - data.sort(c); - } - // ---- Optional, but for speed @Override @@ -140,12 +135,12 @@ public class ArrayLadderOpen implements LadderOpen,RopeIterable { } @Override - public int indexOf(Object o) { + public long indexOf(Object o) { return data.indexOf(o); } @Override - public int lastIndexOf(Object o) { + public long lastIndexOf(Object o) { return data.lastIndexOf(o); } @@ -194,11 +189,6 @@ public class ArrayLadderOpen implements LadderOpen,RopeIterable { return data.containsAll(set.toCollection()); } - @Override - public Stream parallelStream() { - return data.parallelStream(); - } - @Override public Spliterator spliterator() { return data.spliterator(); @@ -214,16 +204,6 @@ public class ArrayLadderOpen implements LadderOpen,RopeIterable { return data.addAll(c.toCollection()); } -// @Override -// public void forEach(Consumer action) { -// data.forEach(action); -// } -// -// @Override -// public Spliterator spliterator() { -// return data.spliterator(); -// } - @Override public boolean addAll(long index, Yarn c) { return data.addAll((int) index, c.toCollection()); diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java index 28babc8..5985570 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java @@ -43,15 +43,34 @@ public interface Ladder extends Yarn { } default E get(long index) { - return stream().skip(index).collect(Collectors.toList()).get(0); + return stream().skip(index).findFirst().get(); } - default int indexOf(Object o) { - return stream().collect(Collectors.toList()).indexOf(o); + // TODO: replace all "long" with ~ZerdinalX63 (extends ZerdinalX0) + default long indexOf(Object obj) { + long ladderSize = size(); + for (long i = 0; i < ladderSize; i++) { + E v = get(i); + if (v == null && obj == null) { + return i; + } + if (v != null && v.equals(obj)) { + return i; + } + } + return -1L; } - default int lastIndexOf(Object o) { - return stream().collect(Collectors.toList()).lastIndexOf(o); + default long lastIndexOf(Object obj) { + long lastIdx = -1L; + long currIdx = 0L; + while (currIdx != -1L) { + currIdx = indexOf(obj); + if (currIdx != -1L) { + lastIdx = currIdx; + } + } + return lastIdx; } default RopeLadder ropeLadder() { diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/LadderOpen.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/LadderOpen.java index eb52069..dd78be5 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/LadderOpen.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/LadderOpen.java @@ -27,8 +27,11 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ; +import java.util.Arrays; import java.util.Comparator; +import java.util.Objects; import java.util.function.UnaryOperator; +import java.util.stream.Collector; import java.util.stream.Collectors; import ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᙆᓫᣗᒄᑊᣕᣔᒻ.Zerdinal; @@ -56,6 +59,7 @@ public interface LadderOpen extends Ladder, YarnOpen { boolean result = iterator.hasNext(); while (iterator.hasNext()) { add(index, iterator.next()); + index++; } return result; } @@ -67,6 +71,7 @@ public interface LadderOpen extends Ladder, YarnOpen { E remove(long index); default void replaceAll(UnaryOperator operator) { + Objects.requireNonNull(operator); for (int i = 0; i < size(); i++) { set(i, operator.apply(get(i))); } @@ -78,7 +83,15 @@ public interface LadderOpen extends Ladder, YarnOpen { E set(long index, E element); - /* default */ void sort(Comparator c); + @SuppressWarnings({ "unchecked", "rawtypes" }) + default void sort(Comparator c) { + // TODO: int limited + Object[] arr = toArray(); + Arrays.sort(arr, (Comparator) c); + for (int i = 0; i < arr.length; i++) { + set(i, (E) arr[i]); + } + } default RopeLadderOpen ropeLadderOpen() { return ropeLadderOpen(); @@ -98,7 +111,12 @@ public interface LadderOpen extends Ladder, YarnOpen { } default LadderOpen subLadderOpen(long fromIndex, long toIndex) { - // TODO: fix cast - return new ArrayLadderOpen<>(stream().collect(Collectors.toList()).subList((int) fromIndex, (int) toIndex)); + //return new ArrayLadderOpen<>(stream().collect(Collectors.toList()).subList((int) fromIndex, (int) toIndex)); + return stream().skip(fromIndex).limit(toIndex).collect(LadderOpen.ofCollector()); + } + + //TODO: move? + public static Collector> ofCollector() { + return Collector.of(ArrayLadderOpen::new , LadderOpen::add, (v1, v2) -> { v1.addAll(v2); return v1; }, Collector.Characteristics.IDENTITY_FINISH); } } diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Yarn.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Yarn.java index aea042f..fe9787b 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Yarn.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Yarn.java @@ -28,8 +28,8 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ; import java.util.Collection; -import java.util.Spliterator; -import java.util.Spliterators; +import java.util.Iterator; +import java.util.Objects; import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; @@ -51,37 +51,79 @@ public interface Yarn extends RopeIterable { } default boolean contains(Object obj) { - return stream().collect(Collectors.toSet()).contains(obj); + Objects.requireNonNull(obj); + return stream().collect(Collectors.toList()).contains(obj); } default boolean containsAll(Yarn set) { - return stream().collect(Collectors.toSet()).containsAll(set.stream().collect(Collectors.toSet())); - } - - default Stream parallelStream() { - return stream().parallel(); - } - - default Spliterator spliterator() { - return Spliterators.spliteratorUnknownSize(rope().toIterator(), Spliterator.ORDERED); - } - - @Deprecated // limited to int size - default Object[] toArray() { - return stream().collect(Collectors.toList()).toArray(); - } - - @Deprecated // limited to int size - default T[] toArray(T[] arr) { - return stream().collect(Collectors.toList()).toArray(arr); + Objects.requireNonNull(set); + return stream().collect(Collectors.toList()).containsAll(set.toCollection()); } default Stream stream() { return StreamSupport.stream(spliterator(), false); } - // TODO; add interface wrappers default Collection toCollection() { - return stream().collect(Collectors.toList()); + return wrapᴼᶠ(this); + } + + static Collection wrapᴼᶠ(Yarn wrap) { + Objects.requireNonNull(wrap); + Objects.checkIndex(wrap.size(), Integer.MAX_VALUE); + return new Collection<>() { + @Override + public int size() { + return (int) wrap.size(); + } + @Override + public boolean isEmpty() { + return wrap.isEmpty(); + } + @Override + public boolean contains(Object obj) { + return wrap.contains(obj); + } + @Override + public boolean containsAll(Collection collection) { + return wrap.containsAll(YarnOpen.wrapᴼᶠ(collection)); + } + @Override + public Iterator iterator() { + return wrap.rope().toIterator(); + } + @Override + public Object[] toArray() { + return wrap.stream().collect(Collectors.toList()).toArray(); + } + @Override + public X[] toArray(X[] arr) { + return wrap.stream().collect(Collectors.toList()).toArray(arr); + } + @Override + public boolean add(T obj) { + throw new UnsupportedOperationException(); + } + @Override + public boolean addAll(Collection collection) { + throw new UnsupportedOperationException(); + } + @Override + public boolean remove(Object obj) { + throw new UnsupportedOperationException(); + } + @Override + public boolean removeAll(Collection collection) { + throw new UnsupportedOperationException(); + } + @Override + public boolean retainAll(Collection collection) { + throw new UnsupportedOperationException(); + } + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + }; } } diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java index f8476b3..9e7d011 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java @@ -48,10 +48,11 @@ public interface YarnOpen extends Yarn, AppenderOpen { } default boolean removeAll(Yarn yarn) { + Objects.requireNonNull(yarn); boolean result = false; - Rope iterator = yarn.rope(); - while (iterator.hasNext()) { - if (remove(iterator.next())) { + Rope rope = yarn.rope(); + while (rope.hasNext()) { + if (remove(rope.next())) { result = true; } } @@ -59,12 +60,14 @@ public interface YarnOpen extends Yarn, AppenderOpen { } default boolean removeIf(Predicate filter) { - return removeAll(new ArrayLadderOpen<>(this.stream().filter(filter).toList())); + Objects.requireNonNull(filter); + return removeAll(new ArrayLadderOpen<>(stream().filter(filter).toList())); } default boolean retainAll(Yarn yarn) { + Objects.requireNonNull(yarn); boolean result = false; - for (E e:stream().collect(Collectors.toList())) { + for (E e : stream().collect(Collectors.toList())) { if (!yarn.contains(e)) { remove(e); result = true; @@ -77,97 +80,80 @@ public interface YarnOpen extends Yarn, AppenderOpen { return wrapᴼᶠ(this); } - static YarnOpen wrapᴼᶠ(Collection collection) { - Objects.requireNonNull(collection); + static YarnOpen wrapᴼᶠ(Collection wrap) { + Objects.requireNonNull(wrap); return new YarnOpen<>() { - @Override public Rope rope() { - return Rope.wrapᴼᶠ(collection.iterator()); + return Rope.wrapᴼᶠ(wrap.iterator()); } - @Override public boolean add(T obj) { - return collection.add(obj); + return wrap.add(obj); } - @Override public boolean remove(Object obj) { - return collection.remove(obj); + return wrap.remove(obj); } - }; } - static Collection wrapᴼᶠ(YarnOpen yarn) { - Objects.requireNonNull(yarn); + static Collection wrapᴼᶠ(YarnOpen wrap) { + Objects.requireNonNull(wrap); + Objects.checkIndex(wrap.size(), Integer.MAX_VALUE); return new Collection<>() { - @Override public int size() { - return (int) yarn.size(); + return (int) wrap.size(); } - @Override public boolean isEmpty() { - return yarn.isEmpty(); + return wrap.isEmpty(); } - @Override public boolean contains(Object obj) { - return yarn.contains(obj); + return wrap.contains(obj); } - - @Override - public Iterator iterator() { - return yarn.rope().toIterator(); - } - - @Override - public Object[] toArray() { - return yarn.toArray(); - } - - @Override - public T[] toArray(T[] arr) { - return yarn.toArray(arr); - } - - @Override - public boolean add(T obj) { - return yarn.add(obj); - } - - @Override - public boolean remove(Object obj) { - return yarn.remove(obj); - } - @Override public boolean containsAll(Collection collection) { - return yarn.containsAll(YarnOpen.wrapᴼᶠ(collection)); + return wrap.containsAll(YarnOpen.wrapᴼᶠ(collection)); + } + @Override + public Iterator iterator() { + return wrap.rope().toIterator(); + } + @Override + public Object[] toArray() { + return wrap.stream().collect(Collectors.toList()).toArray(); + } + @Override + public X[] toArray(X[] arr) { + return wrap.stream().collect(Collectors.toList()).toArray(arr); + } + @Override + public boolean add(T obj) { + return wrap.add(obj); } - @Override public boolean addAll(Collection collection) { - return yarn.addAll(YarnOpen.wrapᴼᶠ(collection)); + return wrap.addAll(YarnOpen.wrapᴼᶠ(collection)); + } + @Override + public boolean remove(Object obj) { + return wrap.remove(obj); } - @Override public boolean removeAll(Collection collection) { - return yarn.removeAll(YarnOpen.wrapᴼᶠ(collection)); + return wrap.removeAll(YarnOpen.wrapᴼᶠ(collection)); } - @Override public boolean retainAll(Collection collection) { - return yarn.retainAll(YarnOpen.wrapᴼᶠ(collection)); + return wrap.retainAll(YarnOpen.wrapᴼᶠ(collection)); } - @Override public void clear() { - yarn.clear(); + wrap.clear(); } - }; } } diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/Rope.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/Rope.java index 982138b..213103e 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/Rope.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/Rope.java @@ -28,6 +28,7 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ; import java.util.Iterator; +import java.util.Objects; import java.util.function.Consumer; /// Read Only Programmable Enumeration. @@ -50,32 +51,30 @@ public interface Rope { } } - static Iterator wrapᴼᶠ(Rope iterator) { + static Iterator wrapᴼᶠ(Rope wrap) { + Objects.requireNonNull(wrap); return new Iterator<>() { - @Override public boolean hasNext() { - return iterator.hasNext(); + return wrap.hasNext(); } - @Override public T next() { - return iterator.next(); + return wrap.next(); } }; } - static Rope wrapᴼᶠ(Iterator iterator) { + static Rope wrapᴼᶠ(Iterator wrap) { + Objects.requireNonNull(wrap); return new Rope<>() { - @Override public boolean hasNext() { - return iterator.hasNext(); + return wrap.hasNext(); } - @Override public T next() { - return iterator.next(); + return wrap.next(); } }; } diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeIterable.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeIterable.java index 6631452..5b045ee 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeIterable.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeIterable.java @@ -31,8 +31,6 @@ import java.util.Iterator; import java.util.Spliterator; import java.util.Spliterators; import java.util.function.Consumer; -import java.util.stream.Collector; -import java.util.stream.StreamSupport; /// Make an object iterable with a rope. /// @@ -48,11 +46,7 @@ public interface RopeIterable { } default Spliterator spliterator() { - return Spliterators.spliteratorUnknownSize(rope().toIterator(), Spliterator.ORDERED); - } - - default R collect(Collector collector) { - return StreamSupport.stream(spliterator(), false).collect(collector); + return Spliterators.spliteratorUnknownSize(rope().toIterator(), 0); } default Iterable toIterable() { diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadder.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadder.java index 474d62b..ef91f01 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadder.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadder.java @@ -28,6 +28,7 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ; import java.util.ListIterator; +import java.util.Objects; /// Rope ladder /// @@ -37,37 +38,38 @@ public interface RopeLadder extends Rope { boolean hasPrevious(); - long nextIndex(); - E previous(); + long nextIndex(); + long previousIndex(); - static RopeLadder wrapᴼᶠ(ListIterator iterator) { + static RopeLadder wrapᴼᶠ(ListIterator wrap) { + Objects.requireNonNull(wrap); return new RopeLadder<>() { @Override public boolean hasNext() { - return iterator.hasNext(); + return wrap.hasNext(); } @Override public T next() { - return iterator.next(); + return wrap.next(); } @Override public boolean hasPrevious() { - return iterator.hasPrevious(); - } - @Override - public long nextIndex() { - return iterator.nextIndex(); + return wrap.hasPrevious(); } @Override public T previous() { - return iterator.previous(); + return wrap.previous(); + } + @Override + public long nextIndex() { + return wrap.nextIndex(); } @Override public long previousIndex() { - return iterator.previousIndex(); + return wrap.previousIndex(); } }; } diff --git a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadderOpen.java b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadderOpen.java index 469528c..5b0bd5d 100644 --- a/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadderOpen.java +++ b/nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/ᣗᐤᣖᓫ/RopeLadderOpen.java @@ -28,6 +28,7 @@ package ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.ᣗᐤᣖᓫ; import java.util.ListIterator; +import java.util.Objects; /// Rope ladder open /// @@ -37,93 +38,95 @@ public interface RopeLadderOpen extends RopeLadder, Rope { void remove(); - void add(E obj); - void set(E obj); + void add(E obj); + default ListIterator toListIterator() { return wrapᴼᶠ(this); } @Deprecated // limited to int - static ListIterator wrapᴼᶠ(RopeLadderOpen iterator) { + static ListIterator wrapᴼᶠ(RopeLadderOpen wrap) { + Objects.requireNonNull(wrap); return new ListIterator<>() { @Override public boolean hasNext() { - return iterator.hasNext(); + return wrap.hasNext(); } @Override public T next() { - return iterator.next(); - } - @Override - public void add(T obj) { - iterator.add(obj); + return wrap.next(); } @Override public boolean hasPrevious() { - return iterator.hasPrevious(); - } - @Override - public int nextIndex() { - return (int) iterator.nextIndex(); + return wrap.hasPrevious(); } @Override public T previous() { - return iterator.previous(); + return wrap.previous(); + } + @Override + public int nextIndex() { + return (int) wrap.nextIndex(); } @Override public int previousIndex() { - return (int) iterator.previousIndex(); + return (int) wrap.previousIndex(); } @Override public void remove() { - iterator.remove(); + wrap.remove(); } @Override public void set(T obj) { - iterator.set(obj); + wrap.set(obj); + } + @Override + public void add(T obj) { + wrap.add(obj); } }; } - static RopeLadderOpen wrapᴼᶠ(ListIterator iterator) { + static RopeLadderOpen wrapᴼᶠ(ListIterator wrap) { + Objects.requireNonNull(wrap); return new RopeLadderOpen<>() { @Override public boolean hasNext() { - return iterator.hasNext(); + return wrap.hasNext(); } @Override public T next() { - return iterator.next(); + return wrap.next(); } @Override public boolean hasPrevious() { - return iterator.hasPrevious(); - } - @Override - public long nextIndex() { - return iterator.nextIndex(); + return wrap.hasPrevious(); } @Override public T previous() { - return iterator.previous(); + return wrap.previous(); + } + @Override + public long nextIndex() { + return wrap.nextIndex(); } @Override public long previousIndex() { - return iterator.previousIndex(); - } - @Override - public void add(T obj) { - iterator.add(obj); - } - @Override - public void set(T obj) { - iterator.set(obj); + return wrap.previousIndex(); } @Override public void remove() { - iterator.remove(); + wrap.remove(); + } + @Override + public void set(T obj) { + wrap.set(obj); + } + @Override + public void add(T obj) { + wrap.add(obj); } }; }