From 1f0abcdcd7d73d9fc05f2b0a9f3bb81b27e1e97d Mon Sep 17 00:00:00 2001 From: Bernhard Bonigl Date: Mon, 21 Mar 2016 11:36:35 +0100 Subject: [PATCH] ImmutableConcatList: A list implementation that iterates over multiple lists, treating them as one without copying any elements --- .../mantle/client/model/BakedSimple.java | 15 +- .../mantle/util/ImmutableConcatList.java | 215 ++++++++++++++++++ 2 files changed, 228 insertions(+), 2 deletions(-) create mode 100644 src/main/java/slimeknights/mantle/util/ImmutableConcatList.java diff --git a/src/main/java/slimeknights/mantle/client/model/BakedSimple.java b/src/main/java/slimeknights/mantle/client/model/BakedSimple.java index eb523bb..c142a9b 100644 --- a/src/main/java/slimeknights/mantle/client/model/BakedSimple.java +++ b/src/main/java/slimeknights/mantle/client/model/BakedSimple.java @@ -21,7 +21,7 @@ import javax.vecmath.Matrix4f; public class BakedSimple implements IPerspectiveAwareModel { - private final ImmutableList quads; + private final List quads; private final ImmutableMap transforms; private final TextureAtlasSprite particle; private final boolean ambientOcclusion; @@ -29,6 +29,17 @@ public class BakedSimple implements IPerspectiveAwareModel { private final ItemOverrideList overrides; public BakedSimple(ImmutableList quads, ImmutableMap transforms, IBakedModel base) { + this( + (List)quads, + transforms, + base.getParticleTexture(), + base.isAmbientOcclusion(), + base.isGui3d(), + base.getOverrides() + ); + } + + public BakedSimple(List quads, ImmutableMap transforms, IBakedModel base) { this( quads, transforms, @@ -39,7 +50,7 @@ public class BakedSimple implements IPerspectiveAwareModel { ); } - public BakedSimple(ImmutableList quads, ImmutableMap transforms, TextureAtlasSprite particle, boolean ambientOcclusion, boolean isGui3d, ItemOverrideList overrides) { + public BakedSimple(List quads, ImmutableMap transforms, TextureAtlasSprite particle, boolean ambientOcclusion, boolean isGui3d, ItemOverrideList overrides) { this.quads = quads; this.particle = particle; this.transforms = transforms; diff --git a/src/main/java/slimeknights/mantle/util/ImmutableConcatList.java b/src/main/java/slimeknights/mantle/util/ImmutableConcatList.java new file mode 100644 index 0000000..1b74a98 --- /dev/null +++ b/src/main/java/slimeknights/mantle/util/ImmutableConcatList.java @@ -0,0 +1,215 @@ +package slimeknights.mantle.util; + +import com.google.common.collect.FluentIterable; +import com.google.common.collect.Iterables; +import com.google.common.collect.UnmodifiableListIterator; + +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.NoSuchElementException; + +import static com.google.common.base.Preconditions.checkPositionIndex; + +public class ImmutableConcatList implements List { + + protected final FluentIterable iterable; + + public ImmutableConcatList(List... lists) { + iterable = FluentIterable.from(Iterables.concat(lists)); + } + + public ImmutableConcatList(List> lists) { + iterable = FluentIterable.from(Iterables.concat(lists)); + } + + @Override + public int size() { + return iterable.size(); + } + + @Override + public boolean isEmpty() { + return iterable.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return iterable.contains(o); + } + + @Override + public Iterator iterator() { + return iterable.iterator(); + } + + @Override + public Object[] toArray() { + return iterable.toList().toArray(); + } + + @Override + public T[] toArray(T[] a) { + return iterable.toList().toArray(a); + } + + @Override + public boolean add(E e) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean remove(Object o) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean containsAll(Collection c) { + for (Object e : c) + if (!contains(e)) + return false; + return true; + } + + @Override + public boolean addAll(Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean addAll(int index, Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean removeAll(Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public boolean retainAll(Collection c) { + throw new UnsupportedOperationException(); + } + + @Override + public void clear() { + throw new UnsupportedOperationException(); + } + + @Override + public E get(int index) { + return iterable.get(index); + } + + @Override + public E set(int index, E element) { + throw new UnsupportedOperationException(); + } + + @Override + public void add(int index, E element) { + throw new UnsupportedOperationException(); + } + + @Override + public E remove(int index) { + throw new UnsupportedOperationException(); + } + + @Override + public int indexOf(final Object o) { + Iterator iterator = iterable.iterator(); + for (int i = 0; iterator.hasNext(); i++) { + if(o == iterator.next()) { + return i; + } + } + + return -1; + } + + @Override + public int lastIndexOf(Object o) { + Iterator iterator = iterable.iterator(); + int j = -1; + for (int i = 0; iterator.hasNext(); i++) { + if(o == iterator.next()) { + j = i; + } + } + + return j; + } + + @Override + public ListIterator listIterator() { + return listIterator(0); + } + + @Override + public ListIterator listIterator(int index) { + return new ListItr(this.size(), index) { + @Override + protected E get(int index) { + return ImmutableConcatList.this.get(index); + } + }; + } + + @Override + public List subList(int fromIndex, int toIndex) { + throw new UnsupportedOperationException(); + } + + // basically a copy of AbstractIndexedListIterator + private abstract static class ListItr extends UnmodifiableListIterator { + + private final int size; + private int position; + + public ListItr(int size, int position) { + checkPositionIndex(position, size); + this.size = size; + this.position = position; + } + + protected abstract E get(int index); + + @Override + public final boolean hasNext() { + return position < size; + } + + @Override + public final E next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return get(position++); + } + + @Override + public final int nextIndex() { + return position; + } + + @Override + public final boolean hasPrevious() { + return position > 0; + } + + @Override + public final E previous() { + if (!hasPrevious()) { + throw new NoSuchElementException(); + } + return get(--position); + } + + @Override + public final int previousIndex() { + return position - 1; + } + } +}