From 9d2d77751c9e4d13427dc00a83625505c2040892 Mon Sep 17 00:00:00 2001 From: Zach Tellman Date: Mon, 8 Dec 2014 10:00:13 +0530 Subject: [PATCH] add unrolled vector implementation --- src/jvm/clojure/lang/PersistentUnrolledVector.java | 1964 ++++++++++++++++++++ 1 file changed, 1964 insertions(+) create mode 100644 src/jvm/clojure/lang/PersistentUnrolledVector.java diff --git a/src/jvm/clojure/lang/PersistentUnrolledVector.java b/src/jvm/clojure/lang/PersistentUnrolledVector.java new file mode 100644 index 0000000..0fac5c6 --- /dev/null +++ b/src/jvm/clojure/lang/PersistentUnrolledVector.java @@ -0,0 +1,1964 @@ +/** + * Copyright (c) Rich Hickey. All rights reserved. + * The use and distribution terms for this software are covered by the + * Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) + * which can be found in the file epl-v10.html at the root of this distribution. + * By using this software in any fashion, you are agreeing to be bound by + * the terms of this license. + * You must not remove this notice, or any other, from this software. + **/ + +// this file is generated by https://github.com/ztellman/cambrian-collections +// do not directly modify + +package clojure.lang; + +import java.util.Iterator; + +public class PersistentUnrolledVector { + static IPersistentVector EMPTY = new Card0(); + + public static IPersistentVector create() { + return EMPTY; + } + + public static IPersistentVector create(Object e0) { + return new Card1(e0); + } + + public static IPersistentVector create(Object e0, Object e1) { + return new Card2(e0, e1); + } + + public static IPersistentVector create(Object e0, Object e1, Object e2) { + return new Card3(e0, e1, e2); + } + + public static IPersistentVector create(Object e0, Object e1, Object e2, + Object e3) { + return new Card4(e0, e1, e2, e3); + } + + public static IPersistentVector create(Object e0, Object e1, Object e2, + Object e3, Object e4) { + return new Card5(e0, e1, e2, e3, e4); + } + + public static IPersistentVector create(Object e0, Object e1, Object e2, + Object e3, Object e4, Object e5) { + return new Card6(e0, e1, e2, e3, e4, e5); + } + + public static class Card0 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + private final IPersistentMap meta; + + Card0(IPersistentMap meta) { + this.meta = meta; + } + + public Card0() { + this.meta = null; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card0(meta); + } + + public Object nth(int i) { + throw new IndexOutOfBoundsException(); + } + + public Object nth(int i, Object notFound) { + return notFound; + } + + public int count() { + return 0; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card1(meta, val); + } + + public ITransientCollection asTransient() { + return new Transient(); + } + + public IPersistentVector pop() { + throw new IllegalStateException("Can't pop empty vector"); + } + + public Object kvreduce(IFn f, Object init) { + return init; + } + + public Object reduce(IFn f) { + return f.invoke(); + } + + public Object reduce(IFn f, Object init) { + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = Murmur3.mixCollHash(hash, 0); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + return o == this ? true : super.equals(o); + } + + public boolean equiv(Object o) { + return o == this ? true : super.equiv(o); + } + + public Object[] toArray() { + return new Object[] {}; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 0; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + public ISeq seq() { + return null; + } + } + + public static class Card1 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + final Object e0; + private final IPersistentMap meta; + + Card1(IPersistentMap meta, Object e0) { + this.meta = meta; + this.e0 = e0; + } + + public Card1(Object e0) { + this.meta = null; + this.e0 = e0; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card1(meta, e0); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + default: + return notFound; + } + } + + public int count() { + return 1; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card1(meta, val); + case 1: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card2(meta, e0, val); + } + + public ITransientCollection asTransient() { + return new Transient(e0); + } + + public IPersistentVector pop() { + return new Card0(meta); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + return e0; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = Murmur3.mixCollHash(hash, 1); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card1) { + return Util.equals(e0, ((Card1) o).e0); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card1) { + return Util.equiv(e0, ((Card1) o).e0); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 1; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 0) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 1 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + public static class Card2 extends APersistentVector implements IObj, + IEditableCollection, IReduce, IMapEntry { + final Object e0; + final Object e1; + private final IPersistentMap meta; + + public Object key() { + return e0; + } + + public Object getKey() { + return e0; + } + + public Object val() { + return e1; + } + + public Object getValue() { + return e1; + } + + public Object setValue(Object v) { + throw new UnsupportedOperationException(); + } + + Card2(IPersistentMap meta, Object e0, Object e1) { + this.meta = meta; + this.e0 = e0; + this.e1 = e1; + } + + public Card2(Object e0, Object e1) { + this.meta = null; + this.e0 = e0; + this.e1 = e1; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card2(meta, e0, e1); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + default: + return notFound; + } + } + + public int count() { + return 2; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card2(meta, val, e1); + case 1: + return new Card2(meta, e0, val); + case 2: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card3(meta, e0, e1, val); + } + + public ITransientCollection asTransient() { + return new Transient(e0, e1); + } + + public IPersistentVector pop() { + return new Card1(meta, e0); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 1, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + Object init = e0; + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + hash = (31 * hash) + (e1 == null ? 0 : e1.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = (31 * hash) + Util.hasheq(e1); + hash = Murmur3.mixCollHash(hash, 2); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card2) { + return Util.equals(e0, ((Card2) o).e0) + && Util.equals(e1, ((Card2) o).e1); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card2) { + return Util.equiv(e0, ((Card2) o).e0) + && Util.equiv(e1, ((Card2) o).e1); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0, e1 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 2; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 1) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 2 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + public static class Card3 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + final Object e0; + final Object e1; + final Object e2; + private final IPersistentMap meta; + + Card3(IPersistentMap meta, Object e0, Object e1, Object e2) { + this.meta = meta; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + } + + public Card3(Object e0, Object e1, Object e2) { + this.meta = null; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card3(meta, e0, e1, e2); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + default: + return notFound; + } + } + + public int count() { + return 3; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card3(meta, val, e1, e2); + case 1: + return new Card3(meta, e0, val, e2); + case 2: + return new Card3(meta, e0, e1, val); + case 3: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card4(meta, e0, e1, e2, val); + } + + public ITransientCollection asTransient() { + return new Transient(e0, e1, e2); + } + + public IPersistentVector pop() { + return new Card2(meta, e0, e1); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 1, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 2, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + Object init = e0; + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + hash = (31 * hash) + (e1 == null ? 0 : e1.hashCode()); + hash = (31 * hash) + (e2 == null ? 0 : e2.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = (31 * hash) + Util.hasheq(e1); + hash = (31 * hash) + Util.hasheq(e2); + hash = Murmur3.mixCollHash(hash, 3); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card3) { + return Util.equals(e0, ((Card3) o).e0) + && Util.equals(e1, ((Card3) o).e1) + && Util.equals(e2, ((Card3) o).e2); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card3) { + return Util.equiv(e0, ((Card3) o).e0) + && Util.equiv(e1, ((Card3) o).e1) + && Util.equiv(e2, ((Card3) o).e2); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0, e1, e2 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 3; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 2) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 3 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + public static class Card4 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + final Object e0; + final Object e1; + final Object e2; + final Object e3; + private final IPersistentMap meta; + + Card4(IPersistentMap meta, Object e0, Object e1, Object e2, Object e3) { + this.meta = meta; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + } + + public Card4(Object e0, Object e1, Object e2, Object e3) { + this.meta = null; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card4(meta, e0, e1, e2, e3); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + default: + return notFound; + } + } + + public int count() { + return 4; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card4(meta, val, e1, e2, e3); + case 1: + return new Card4(meta, e0, val, e2, e3); + case 2: + return new Card4(meta, e0, e1, val, e3); + case 3: + return new Card4(meta, e0, e1, e2, val); + case 4: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card5(meta, e0, e1, e2, e3, val); + } + + public ITransientCollection asTransient() { + return new Transient(e0, e1, e2, e3); + } + + public IPersistentVector pop() { + return new Card3(meta, e0, e1, e2); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 1, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 2, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 3, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + Object init = e0; + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + hash = (31 * hash) + (e1 == null ? 0 : e1.hashCode()); + hash = (31 * hash) + (e2 == null ? 0 : e2.hashCode()); + hash = (31 * hash) + (e3 == null ? 0 : e3.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = (31 * hash) + Util.hasheq(e1); + hash = (31 * hash) + Util.hasheq(e2); + hash = (31 * hash) + Util.hasheq(e3); + hash = Murmur3.mixCollHash(hash, 4); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card4) { + return Util.equals(e0, ((Card4) o).e0) + && Util.equals(e1, ((Card4) o).e1) + && Util.equals(e2, ((Card4) o).e2) + && Util.equals(e3, ((Card4) o).e3); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card4) { + return Util.equiv(e0, ((Card4) o).e0) + && Util.equiv(e1, ((Card4) o).e1) + && Util.equiv(e2, ((Card4) o).e2) + && Util.equiv(e3, ((Card4) o).e3); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0, e1, e2, e3 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 4; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 3) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 4 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + public static class Card5 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + final Object e0; + final Object e1; + final Object e2; + final Object e3; + final Object e4; + private final IPersistentMap meta; + + Card5(IPersistentMap meta, Object e0, Object e1, Object e2, Object e3, + Object e4) { + this.meta = meta; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + } + + public Card5(Object e0, Object e1, Object e2, Object e3, Object e4) { + this.meta = null; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card5(meta, e0, e1, e2, e3, e4); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + case 4: + return e4; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + case 4: + return e4; + default: + return notFound; + } + } + + public int count() { + return 5; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card5(meta, val, e1, e2, e3, e4); + case 1: + return new Card5(meta, e0, val, e2, e3, e4); + case 2: + return new Card5(meta, e0, e1, val, e3, e4); + case 3: + return new Card5(meta, e0, e1, e2, val, e4); + case 4: + return new Card5(meta, e0, e1, e2, e3, val); + case 5: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new Card6(meta, e0, e1, e2, e3, e4, val); + } + + public ITransientCollection asTransient() { + return new Transient(e0, e1, e2, e3, e4); + } + + public IPersistentVector pop() { + return new Card4(meta, e0, e1, e2, e3); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 1, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 2, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 3, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 4, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + Object init = e0; + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + hash = (31 * hash) + (e1 == null ? 0 : e1.hashCode()); + hash = (31 * hash) + (e2 == null ? 0 : e2.hashCode()); + hash = (31 * hash) + (e3 == null ? 0 : e3.hashCode()); + hash = (31 * hash) + (e4 == null ? 0 : e4.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = (31 * hash) + Util.hasheq(e1); + hash = (31 * hash) + Util.hasheq(e2); + hash = (31 * hash) + Util.hasheq(e3); + hash = (31 * hash) + Util.hasheq(e4); + hash = Murmur3.mixCollHash(hash, 5); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card5) { + return Util.equals(e0, ((Card5) o).e0) + && Util.equals(e1, ((Card5) o).e1) + && Util.equals(e2, ((Card5) o).e2) + && Util.equals(e3, ((Card5) o).e3) + && Util.equals(e4, ((Card5) o).e4); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card5) { + return Util.equiv(e0, ((Card5) o).e0) + && Util.equiv(e1, ((Card5) o).e1) + && Util.equiv(e2, ((Card5) o).e2) + && Util.equiv(e3, ((Card5) o).e3) + && Util.equiv(e4, ((Card5) o).e4); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0, e1, e2, e3, e4 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 5; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 4) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 5 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + public static class Card6 extends APersistentVector implements IObj, + IEditableCollection, IReduce { + final Object e0; + final Object e1; + final Object e2; + final Object e3; + final Object e4; + final Object e5; + private final IPersistentMap meta; + + Card6(IPersistentMap meta, Object e0, Object e1, Object e2, Object e3, + Object e4, Object e5) { + this.meta = meta; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + this.e5 = e5; + } + + public Card6(Object e0, Object e1, Object e2, Object e3, Object e4, + Object e5) { + this.meta = null; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + this.e5 = e5; + } + + public IPersistentMap meta() { + return meta; + } + + public IObj withMeta(IPersistentMap meta) { + return new Card6(meta, e0, e1, e2, e3, e4, e5); + } + + public Object nth(int i) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + case 4: + return e4; + case 5: + return e5; + default: + throw new IndexOutOfBoundsException(); + } + } + + public Object nth(int i, Object notFound) { + switch (i) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + case 4: + return e4; + case 5: + return e5; + default: + return notFound; + } + } + + public int count() { + return 6; + } + + public IPersistentVector empty() { + return EMPTY; + } + + public IPersistentVector assocN(int i, Object val) { + switch (i) { + case 0: + return new Card6(meta, val, e1, e2, e3, e4, e5); + case 1: + return new Card6(meta, e0, val, e2, e3, e4, e5); + case 2: + return new Card6(meta, e0, e1, val, e3, e4, e5); + case 3: + return new Card6(meta, e0, e1, e2, val, e4, e5); + case 4: + return new Card6(meta, e0, e1, e2, e3, val, e5); + case 5: + return new Card6(meta, e0, e1, e2, e3, e4, val); + case 6: + return cons(val); + default: + throw new IndexOutOfBoundsException(); + } + } + + public IPersistentVector cons(Object val) { + return new PersistentVector(meta, 7, 5, + PersistentVector.EMPTY_NODE, new Object[] { e0, e1, e2, e3, + e4, e5, val }); + } + + public ITransientCollection asTransient() { + return new Transient(e0, e1, e2, e3, e4, e5); + } + + public IPersistentVector pop() { + return new Card5(meta, e0, e1, e2, e3, e4); + } + + public Object kvreduce(IFn f, Object init) { + init = f.invoke(init, 0, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 1, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 2, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 3, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 4, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, 5, e5); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f) { + Object init = e0; + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e5); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public Object reduce(IFn f, Object init) { + init = f.invoke(init, e0); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e1); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e2); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e3); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e4); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + init = f.invoke(init, e5); + if (RT.isReduced(init)) { + return ((IDeref) init).deref(); + } + return init; + } + + public int hashCode() { + if (_hash == -1) { + int hash = 1; + hash = (31 * hash) + (e0 == null ? 0 : e0.hashCode()); + hash = (31 * hash) + (e1 == null ? 0 : e1.hashCode()); + hash = (31 * hash) + (e2 == null ? 0 : e2.hashCode()); + hash = (31 * hash) + (e3 == null ? 0 : e3.hashCode()); + hash = (31 * hash) + (e4 == null ? 0 : e4.hashCode()); + hash = (31 * hash) + (e5 == null ? 0 : e5.hashCode()); + _hash = hash; + } + return _hash; + } + + public int hasheq() { + if (_hasheq == -1) { + int hash = 1; + hash = (31 * hash) + Util.hasheq(e0); + hash = (31 * hash) + Util.hasheq(e1); + hash = (31 * hash) + Util.hasheq(e2); + hash = (31 * hash) + Util.hasheq(e3); + hash = (31 * hash) + Util.hasheq(e4); + hash = (31 * hash) + Util.hasheq(e5); + hash = Murmur3.mixCollHash(hash, 6); + _hasheq = hash; + } + return _hasheq; + } + + public boolean equals(Object o) { + if (o instanceof Card6) { + return Util.equals(e0, ((Card6) o).e0) + && Util.equals(e1, ((Card6) o).e1) + && Util.equals(e2, ((Card6) o).e2) + && Util.equals(e3, ((Card6) o).e3) + && Util.equals(e4, ((Card6) o).e4) + && Util.equals(e5, ((Card6) o).e5); + } else { + return super.equals(o); + } + } + + public boolean equiv(Object o) { + if (o instanceof Card6) { + return Util.equiv(e0, ((Card6) o).e0) + && Util.equiv(e1, ((Card6) o).e1) + && Util.equiv(e2, ((Card6) o).e2) + && Util.equiv(e3, ((Card6) o).e3) + && Util.equiv(e4, ((Card6) o).e4) + && Util.equiv(e5, ((Card6) o).e5); + } else { + return super.equiv(o); + } + } + + public Object[] toArray() { + return new Object[] { e0, e1, e2, e3, e4, e5 }; + } + + public Iterator iterator() { + return new Iterator() { + int i = 0; + + public boolean hasNext() { + return i < 6; + } + + public Object next() { + return nth(i++); + } + + public void remove() { + throw new UnsupportedOperationException(); + } + }; + } + + class UnrolledChunkedSeq extends ASeq implements IChunkedSeq, Counted { + private final IPersistentMap meta; + private final int offset; + + UnrolledChunkedSeq(IPersistentMap meta, int offset) { + this.offset = offset; + this.meta = meta; + } + + public IChunk chunkedFirst() { + return new ArrayChunk(toArray(), offset); + } + + public ISeq chunkedNext() { + return null; + } + + public ISeq chunkedMore() { + return PersistentList.EMPTY; + } + + public UnrolledChunkedSeq withMeta(IPersistentMap meta) { + return new UnrolledChunkedSeq(meta, offset); + } + + public Object first() { + return nth(offset); + } + + public ISeq next() { + if (offset < 5) { + return new UnrolledChunkedSeq(null, offset + 1); + } + return null; + } + + public int count() { + return 6 - offset; + } + } + + public ISeq seq() { + return new UnrolledChunkedSeq(null, 0); + } + } + + static class Transient extends AFn implements ITransientVector, Counted { + Object e0; + Object e1; + Object e2; + Object e3; + Object e4; + Object e5; + private int count; + private transient boolean edit = true; + + Transient() { + this.count = 0; + } + + Transient(Object e0) { + this.count = 1; + this.e0 = e0; + } + + Transient(Object e0, Object e1) { + this.count = 2; + this.e0 = e0; + this.e1 = e1; + } + + Transient(Object e0, Object e1, Object e2) { + this.count = 3; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + } + + Transient(Object e0, Object e1, Object e2, Object e3) { + this.count = 4; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + } + + Transient(Object e0, Object e1, Object e2, Object e3, Object e4) { + this.count = 5; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + } + + Transient(Object e0, Object e1, Object e2, Object e3, Object e4, + Object e5) { + this.count = 6; + this.e0 = e0; + this.e1 = e1; + this.e2 = e2; + this.e3 = e3; + this.e4 = e4; + this.e5 = e5; + } + + private void ensureEditable() { + if (!edit) { + throw new IllegalAccessError( + "Transient used after persistent! call"); + } + } + + public int count() { + ensureEditable(); + return count; + } + + public ITransientVector conj(Object val) { + ensureEditable(); + if (count == 6) { + return new PersistentVector(7, 5, PersistentVector.EMPTY_NODE, + new Object[] { e0, e1, e2, e3, e4, e5, val }) + .asTransient(); + } + switch (++count) { + case 1: + e0 = val; + break; + case 2: + e1 = val; + break; + case 3: + e2 = val; + break; + case 4: + e3 = val; + break; + case 5: + e4 = val; + break; + case 6: + e5 = val; + break; + } + return this; + } + + public Object valAt(Object key, Object notFound) { + if (Util.isInteger(key)) { + return nth(((Number) key).intValue(), notFound); + } + return notFound; + } + + public Object valAt(Object key) { + if (Util.isInteger(key)) { + return nth(((Number) key).intValue()); + } + throw new IllegalArgumentException("Key must be integer"); + } + + public Object invoke(Object key) { + return valAt(key); + } + + public Object nth(int idx) { + if (idx >= 0 && idx < count) { + switch (idx) { + case 0: + return e0; + case 1: + return e1; + case 2: + return e2; + case 3: + return e3; + case 4: + return e4; + case 5: + return e5; + } + } + throw new IndexOutOfBoundsException(); + } + + public Object nth(int idx, Object notFound) { + if (idx >= 0 && idx < count) { + return nth(idx); + } + return notFound; + } + + public ITransientVector assoc(Object key, Object val) { + if (Util.isInteger(key)) { + return assocN(((Number) key).intValue(), val); + } + throw new IllegalArgumentException("Key must be integer"); + } + + public ITransientVector assocN(int idx, Object val) { + ensureEditable(); + if (idx >= 0 && idx < count) { + switch (idx) { + case 0: + e0 = val; + break; + case 1: + e1 = val; + break; + case 2: + e2 = val; + break; + case 3: + e3 = val; + break; + case 4: + e4 = val; + break; + case 5: + e5 = val; + break; + } + return this; + } else if (idx == count) { + return conj(val); + } + throw new IndexOutOfBoundsException(); + } + + public ITransientVector pop() { + ensureEditable(); + if (count == 0) { + throw new IllegalStateException("Can't pop empty vector"); + } else { + count--; + } + return this; + } + + public IPersistentVector persistent() { + ensureEditable(); + edit = false; + switch (count) { + case 0: + return EMPTY; + case 1: + return new Card1(e0); + case 2: + return new Card2(e0, e1); + case 3: + return new Card3(e0, e1, e2); + case 4: + return new Card4(e0, e1, e2, e3); + case 5: + return new Card5(e0, e1, e2, e3, e4); + case 6: + return new Card6(e0, e1, e2, e3, e4, e5); + } + throw new IllegalStateException(); + } + } +} \ No newline at end of file -- 2.1.2