JPP: Small fixes in collection2 to think abount X0 naming

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<E> implements LadderOpen<E>,RopeIterable<E> {
 		return data.set((int) index, element);
 	}
 	
-	@Override
-	public void sort(Comparator<? super E> c) { // TODO: add default impl
-		data.sort(c);
-	}
-	
 	// ---- Optional, but for speed
 	
 	@Override
@@ -140,12 +135,12 @@ public class ArrayLadderOpen<E> implements LadderOpen<E>,RopeIterable<E> {
 	}
 	
 	@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<E> implements LadderOpen<E>,RopeIterable<E> {
 		return data.containsAll(set.toCollection());
 	}
 	
-	@Override
-	public Stream<E> parallelStream() {
-		return data.parallelStream();
-	}
-	
 	@Override
 	public Spliterator<E> spliterator() {
 		return data.spliterator();
@@ -214,16 +204,6 @@ public class ArrayLadderOpen<E> implements LadderOpen<E>,RopeIterable<E> {
 		return data.addAll(c.toCollection());
 	}
 	
-//	@Override
-//	public void forEach(Consumer<? super E> action) {
-//		data.forEach(action);
-//	}
-//	
-//	@Override
-//	public Spliterator<E> spliterator() {
-//		return data.spliterator();
-//	}
-	
 	@Override
 	public boolean addAll(long index, Yarn<? extends E> c) {
 		return data.addAll((int) index, c.toCollection());

nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/Ladder.java

@@ -43,15 +43,34 @@ public interface Ladder<E> extends Yarn<E> {
 	}
 	
 	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<Long>)
+	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<E> ropeLadder() {

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<E> extends Ladder<E>, YarnOpen<E> {
 		boolean result = iterator.hasNext();
 		while (iterator.hasNext()) {
 			add(index, iterator.next());
+			index++;
 		}
 		return result;
 	}
@@ -67,6 +71,7 @@ public interface LadderOpen<E> extends Ladder<E>, YarnOpen<E> {
 	E remove(long index);
 	
 	default void replaceAll(UnaryOperator<E> operator) {
+		Objects.requireNonNull(operator);
 		for (int i = 0; i < size(); i++) {
 			set(i, operator.apply(get(i)));
 		}
@@ -78,7 +83,15 @@ public interface LadderOpen<E> extends Ladder<E>, YarnOpen<E> {
 	
 	E set(long index, E element);
 	
-	/* default */ void sort(Comparator<? super E> c);
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	default void sort(Comparator<? super E> 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<E> ropeLadderOpen() {
 		return ropeLadderOpen();
@@ -98,7 +111,12 @@ public interface LadderOpen<E> extends Ladder<E>, YarnOpen<E> {
 	}
 	
 	default LadderOpen<E> 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 <T> Collector<T, ?, LadderOpen<T>> ofCollector() {
+		return Collector.of(ArrayLadderOpen::new , LadderOpen::add, (v1, v2) -> { v1.addAll(v2); return v1; }, Collector.Characteristics.IDENTITY_FINISH);
 	}
 }

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<E> extends RopeIterable<E> {
 	}
 	
 	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<E> parallelStream() {
-		return stream().parallel();
-	}
-	
-	default Spliterator<E> 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> T[] toArray(T[] arr) {
-		return stream().collect(Collectors.toList()).toArray(arr);
+		Objects.requireNonNull(set);
+		return stream().collect(Collectors.toList()).containsAll(set.toCollection());
 	}
 	
 	default Stream<E> stream() {
 		return StreamSupport.stream(spliterator(), false);
 	}
 	
-	// TODO; add interface wrappers
 	default Collection<E> toCollection() {
-		return stream().collect(Collectors.toList());
+		return wrapᴼᶠ(this);
+	}
+	
+	static <T> Collection<T> wrapᴼᶠ(Yarn<T> 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<T> iterator() {
+				return wrap.rope().toIterator();
+			}
+			@Override
+			public Object[] toArray() {
+				return wrap.stream().collect(Collectors.toList()).toArray();
+			}
+			@Override
+			public <X> 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<? extends T> 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();
+			}
+		};
 	}
 }

nx01-jpp0-collections2/src/main/java/ᒢᣘᐧᐧ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ/YarnOpen.java

@@ -48,10 +48,11 @@ public interface YarnOpen<E> extends Yarn<E>, AppenderOpen<E> {
 	}
 	
 	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<E> extends Yarn<E>, AppenderOpen<E> {
 	}
 	
 	default boolean removeIf(Predicate<? super E> 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<E> extends Yarn<E>, AppenderOpen<E> {
 		return wrapᴼᶠ(this);
 	}
 	
-	static <T> YarnOpen<T> wrapᴼᶠ(Collection<T> collection) {
-		Objects.requireNonNull(collection);
+	static <T> YarnOpen<T> wrapᴼᶠ(Collection<T> wrap) {
+		Objects.requireNonNull(wrap);
 		return new YarnOpen<>() {
-
 			@Override
 			public Rope<T> 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 <T> Collection<T> wrapᴼᶠ(YarnOpen<T> yarn) {
-		Objects.requireNonNull(yarn);
+	static <T> Collection<T> wrapᴼᶠ(YarnOpen<T> 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<T> iterator() {
-				return yarn.rope().toIterator();
-			}
-
-			@Override
-			public Object[] toArray() {
-				return yarn.toArray();
-			}
-
-			@Override
-			public <T> 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<T> iterator() {
+				return wrap.rope().toIterator();
+			}
+			@Override
+			public Object[] toArray() {
+				return wrap.stream().collect(Collectors.toList()).toArray();
+			}
+			@Override
+			public <X> 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<? extends T> 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();
 			}
-			
 		};
 	}
 }

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<E> {
 		}
 	}
 	
-	static <T> Iterator<T> wrapᴼᶠ(Rope<T> iterator) {
+	static <T> Iterator<T> wrapᴼᶠ(Rope<T> 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 <T> Rope<T> wrapᴼᶠ(Iterator<T> iterator) {
+	static <T> Rope<T> wrapᴼᶠ(Iterator<T> 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();
 			}
 		};
 	}

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<E> {
 	}
 	
 	default Spliterator<E> spliterator() {
-		return Spliterators.spliteratorUnknownSize(rope().toIterator(), Spliterator.ORDERED);
-	}
-	
-	default <A, R> R collect(Collector<? super E, A, R> collector) {
-		return StreamSupport.stream(spliterator(), false).collect(collector);
+		return Spliterators.spliteratorUnknownSize(rope().toIterator(), 0);
 	}
 	
 	default Iterable<E> toIterable() {

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<E> extends Rope<E> {
 	
 	boolean hasPrevious();
 	
-	long nextIndex();
-	
 	E previous();
 	
+	long nextIndex();
+	
 	long previousIndex();
 	
-	static <T> RopeLadder<T> wrapᴼᶠ(ListIterator<T> iterator) {
+	static <T> RopeLadder<T> wrapᴼᶠ(ListIterator<T> 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();
 			}
 		};
 	}

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<E> extends RopeLadder<E>, Rope<E> {
 	
 	void remove();
 	
-	void add(E obj);
-	
 	void set(E obj);
 	
+	void add(E obj);
+	
 	default ListIterator<E> toListIterator() {
 		return wrapᴼᶠ(this);
 	}
 	
 	@Deprecated // limited to int
-	static <T> ListIterator<T> wrapᴼᶠ(RopeLadderOpen<T> iterator) {
+	static <T> ListIterator<T> wrapᴼᶠ(RopeLadderOpen<T> 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 <T> RopeLadderOpen<T> wrapᴼᶠ(ListIterator<T> iterator) {
+	static <T> RopeLadderOpen<T> wrapᴼᶠ(ListIterator<T> 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);
 			}
 		};
 	}