Disable tuple impl, leaving integration. APersistentVector implements…

… IMapEntry
clojure · Jul 25, 2015 · 8383026 · 8383026
1 parent 494ab13
commit 8383026
Show file tree

Hide file tree

Showing 7 changed files with 66 additions and 502 deletions.
diff --git a/src/jvm/clojure/lang/APersistentVector.java b/src/jvm/clojure/lang/APersistentVector.java
@@ -16,7 +16,7 @@
 import java.util.*;
 
 public abstract class APersistentVector extends AFn implements IPersistentVector, Iterable,
-                                                               List,
+                                                               List, IMapEntry,
                                                                RandomAccess, Comparable,
                                                                Serializable, IHashEq {
 int _hash = -1;
@@ -126,6 +126,21 @@ else if(obj instanceof List)
 
 }
 
+@Override
+public Object getKey(){
+    return key();
+}
+
+@Override
+public Object getValue(){
+    return val();
+}
+
+@Override
+public Object setValue(Object value){
+    throw new UnsupportedOperationException();
+}
+
 public boolean equals(Object obj){
     if(obj == this)
         return true;
@@ -320,7 +335,7 @@ public IMapEntry entryAt(Object key){
 		{
 		int i = ((Number) key).intValue();
 		if(i >= 0 && i < count())
-			return Tuple.create(key, nth(i));
+			return (IMapEntry) Tuple.create(key, nth(i));
 		}
 	return null;
 }
@@ -430,6 +445,20 @@ else if(count() > v.count())
 	return 0;
 }
 
+@Override
+public Object key(){
+    if(count() == 2)
+        return nth(0);
+    throw new UnsupportedOperationException();
+}
+
+@Override
+public Object val(){
+    if(count() == 2)
+        return nth(1);
+    throw new UnsupportedOperationException();
+}
+
 static class Seq extends ASeq implements IndexedSeq, IReduce{
 	//todo - something more efficient
 	final IPersistentVector v;

diff --git a/src/jvm/clojure/lang/Compiler.java b/src/jvm/clojure/lang/Compiler.java
@@ -156,12 +156,12 @@ public class Compiler implements Opcodes{
 final static Type IOBJ_TYPE = Type.getType(IObj.class);
 final static Type TUPLE_TYPE = Type.getType(Tuple.class);
 final static Method createTupleMethods[] = {Method.getMethod("clojure.lang.IPersistentVector create()"),
-        Method.getMethod("clojure.lang.Tuple$T1 create(Object)"),
-        Method.getMethod("clojure.lang.Tuple$T2 create(Object,Object)"),
-        Method.getMethod("clojure.lang.Tuple$T3 create(Object,Object,Object)"),
-        Method.getMethod("clojure.lang.Tuple$T4 create(Object,Object,Object,Object)"),
-        Method.getMethod("clojure.lang.Tuple$T5 create(Object,Object,Object,Object,Object)"),
-        Method.getMethod("clojure.lang.Tuple$T6 create(Object,Object,Object,Object,Object,Object)")
+        Method.getMethod("clojure.lang.IPersistentVector create(Object)"),
+        Method.getMethod("clojure.lang.IPersistentVector create(Object,Object)"),
+        Method.getMethod("clojure.lang.IPersistentVector create(Object,Object,Object)"),
+        Method.getMethod("clojure.lang.IPersistentVector create(Object,Object,Object,Object)"),
+        Method.getMethod("clojure.lang.IPersistentVector create(Object,Object,Object,Object,Object)"),
+        Method.getMethod("clojure.lang.IPersistentVector create(Object,Object,Object,Object,Object,Object)")
 };
 
 private static final Type[][] ARG_TYPES;
@@ -2939,7 +2939,7 @@ public void emit(C context, ObjExpr objx, GeneratorAdapter gen){
 		if(coll instanceof IPersistentList)
 			gen.getStatic(LIST_TYPE, "EMPTY", EMPTY_LIST_TYPE);
 		else if(coll instanceof IPersistentVector)
-			gen.getStatic(TUPLE_TYPE, "EMPTY", IVECTOR_TYPE);
+			gen.getStatic(VECTOR_TYPE, "EMPTY", VECTOR_TYPE);
 		else if(coll instanceof IPersistentMap)
 				gen.getStatic(HASHMAP_TYPE, "EMPTY", HASHMAP_TYPE);
 			else if(coll instanceof IPersistentSet)
@@ -3233,7 +3233,7 @@ static public Expr parse(C context, IPersistentVector form) {
 					.parse(context == C.EVAL ? context : C.EXPRESSION, ((IObj) form).meta()));
 		else if (constant)
 			{
-			IPersistentVector rv = Tuple.EMPTY;
+			IPersistentVector rv = PersistentVector.EMPTY;
 			for(int i =0;i<args.count();i++)
 				{
 				LiteralExpr ve = (LiteralExpr)args.nth(i);

diff --git a/src/jvm/clojure/lang/LazilyPersistentVector.java b/src/jvm/clojure/lang/LazilyPersistentVector.java
@@ -19,9 +19,10 @@ public class LazilyPersistentVector{
 
 
 static public IPersistentVector createOwning(Object... items){
-	if(items.length <= Tuple.MAX_SIZE)
-        return Tuple.createFromArray(items);
-	else if(items.length <= 32)
+//	if(items.length <= Tuple.MAX_SIZE)
+//        return Tuple.createFromArray(items);
+//	else
+    if(items.length <= 32)
 		return new PersistentVector(items.length, 5, PersistentVector.EMPTY_NODE,items);
 	return PersistentVector.create(items);
 }
@@ -33,10 +34,11 @@ static int fcount(Object c){
 }
 
 static public IPersistentVector create(Object obj){
-   if((obj instanceof Counted || obj instanceof RandomAccess)
-      && fcount(obj) <= Tuple.MAX_SIZE)
-        return Tuple.createFromColl(obj);
-   else if(obj instanceof IReduceInit)
+//   if((obj instanceof Counted || obj instanceof RandomAccess)
+//      && fcount(obj) <= Tuple.MAX_SIZE)
+//        return Tuple.createFromColl(obj);
+//   else
+    if(obj instanceof IReduceInit)
        return PersistentVector.create((IReduceInit) obj);
    else if(obj instanceof ISeq)
        return PersistentVector.create(RT.seq(obj));

diff --git a/src/jvm/clojure/lang/PersistentArrayMap.java b/src/jvm/clojure/lang/PersistentArrayMap.java
@@ -161,7 +161,7 @@ public boolean containsKey(Object key){
 public IMapEntry entryAt(Object key){
 	int i = indexOf(key);
 	if(i >= 0)
-		return Tuple.create(array[i],array[i+1]);
+		return (IMapEntry) Tuple.create(array[i],array[i+1]);
 	return null;
 }
 

diff --git a/src/jvm/clojure/lang/PersistentHashMap.java b/src/jvm/clojure/lang/PersistentHashMap.java
@@ -128,7 +128,7 @@ public boolean containsKey(Object key){
 
 public IMapEntry entryAt(Object key){
 	if(key == null)
-		return hasNull ? Tuple.create(null, nullValue) : null;
+		return hasNull ? (IMapEntry) Tuple.create(null, nullValue) : null;
 	return (root != null) ? root.find(0, hash(key), key) : null;
 }
 
@@ -766,7 +766,7 @@ public IMapEntry find(int shift, int hash, Object key){
 		if(keyOrNull == null)
 			return ((INode) valOrNode).find(shift + 5, hash, key);
 		if(Util.equiv(key, keyOrNull))
-			return Tuple.create(keyOrNull, valOrNode);
+			return (IMapEntry) Tuple.create(keyOrNull, valOrNode);
 		return null;
 	}
 
@@ -967,7 +967,7 @@ public IMapEntry find(int shift, int hash, Object key){
 		if(idx < 0)
 			return null;
 		if(Util.equiv(key, array[idx]))
-			return Tuple.create(array[idx], array[idx+1]);
+			return (IMapEntry) Tuple.create(array[idx], array[idx+1]);
 		return null;
 	}
 

diff --git a/src/jvm/clojure/lang/PersistentStructMap.java b/src/jvm/clojure/lang/PersistentStructMap.java
@@ -132,7 +132,7 @@ public IMapEntry entryAt(Object key){
 	Map.Entry e = def.keyslots.entryAt(key);
 	if(e != null)
 		{
-		return Tuple.create(e.getKey(), vals[(Integer) e.getValue()]);
+		return (IMapEntry) Tuple.create(e.getKey(), vals[(Integer) e.getValue()]);
 		}
 	return ext.entryAt(key);
 }