resolve #80

assira.core/src/main/java/net/ranides/assira/collection/arrays/NativeArray.java

@@ -134,7 +134,7 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
      * @return operator
      */
     public NativeMove moveTo(NativeArray source) {
-        return source.moveTo(this);
+        return source.moveFrom(this);
     }
 
     /**
@@ -693,8 +693,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            byte[] s = source.$array();
-            return (a,b) -> array[a]=s[b];
+            if (source.$array() instanceof byte[]) {
+                byte[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (byte) source.get(b);
+            }
         }
         
         @Override
@@ -734,15 +738,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            ByteArray that = (ByteArray)values;
-            return (a,b) -> Byte.compare(this.array[a], that.array[b]);
+            if(values instanceof ByteArray) {
+                ByteArray that = (ByteArray) values;
+                return (a, b) -> Byte.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Byte.compare(this.array[a], (byte)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            ByteArray that = (ByteArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof ByteArray) {
+                ByteArray that = (ByteArray)values;
+                return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
 
         @Override
@@ -806,8 +818,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            short[] s = source.$array();
-            return (a,b) -> array[a]=s[b];
+            if (source.$array() instanceof short[]) {
+                short[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (short) source.get(b);
+            }
         }
         
         @Override
@@ -847,15 +863,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            ShortArray that = (ShortArray)values;
-            return (a,b) -> Short.compare(this.array[a], that.array[b]);
+            if(values instanceof ShortArray) {
+                ShortArray that = (ShortArray) values;
+                return (a, b) -> Short.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Short.compare(this.array[a], (short)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            ShortArray that = (ShortArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof ShortArray) {
+                ShortArray that = (ShortArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -919,8 +943,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            int[] s = source.$array();
-            return (a,b) -> array[a]=s[b];
+            if (source.$array() instanceof int[]) {
+                int[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (int) source.get(b);
+            }
         }
         
         @Override
@@ -995,19 +1023,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            IntegerArray that = (IntegerArray)values;
-            return (a,b) -> Integer.compare(this.array[a], that.array[b]);
+            if(values instanceof IntegerArray) {
+                IntegerArray that = (IntegerArray) values;
+                return (a, b) -> Integer.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Integer.compare(this.array[a], (int)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            IntegerArray that = (IntegerArray)values;
-            if(cmp instanceof IntComparator) {
-                IntComparator icmp = (IntComparator)cmp;
-                return (a,b) -> icmp.compare(this.array[a], that.array[b]);
+            if(values instanceof IntegerArray && cmp instanceof IntComparator) {
+                IntegerArray that = (IntegerArray) values;
+                IntComparator icmp = (IntComparator) cmp;
+                return (a, b) -> icmp.compare(this.array[a], that.array[b]);
             } else {
-                return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+                return (a, b) -> cmp.compare(this.array[a], values.get(b));
             }
         }
         
@@ -1072,8 +1104,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            long[] s = source.$array();
-            return (a,b) -> array[a]=s[b];
+            if (source.$array() instanceof long[]) {
+                long[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (long) source.get(b);
+            }
         }
         
         @Override
@@ -1113,15 +1149,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            LongArray that = (LongArray)values;
-            return (a,b) -> Long.compare(this.array[a], that.array[b]);
+            if(values instanceof LongArray) {
+                LongArray that = (LongArray) values;
+                return (a, b) -> Long.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Long.compare(this.array[a], (long)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            LongArray that = (LongArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof LongArray) {
+                LongArray that = (LongArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -1185,8 +1229,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            float[] s = source.$array();
-            return (a,b)->{ array[a]=s[b]; };
+            if (source.$array() instanceof float[]) {
+                float[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (float) source.get(b);
+            }
         }
         
         @Override
@@ -1226,15 +1274,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            FloatArray that = (FloatArray)values;
-            return (a,b) -> Float.compare(this.array[a], that.array[b]);
+            if(values instanceof FloatArray) {
+                FloatArray that = (FloatArray) values;
+                return (a, b) -> Float.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Float.compare(this.array[a], (float)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            FloatArray that = (FloatArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof FloatArray) {
+                FloatArray that = (FloatArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -1298,8 +1354,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            double[] s = source.$array();
-            return (a,b)->{ array[a]=s[b]; };
+            if (source.$array() instanceof double[]) {
+                double[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (double) source.get(b);
+            }
         }
         
         @Override
@@ -1339,15 +1399,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            DoubleArray that = (DoubleArray)values;
-            return (a,b) -> Double.compare(this.array[a], that.array[b]);
+            if(values instanceof DoubleArray) {
+                DoubleArray that = (DoubleArray) values;
+                return (a, b) -> Double.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Double.compare(this.array[a], (double)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            DoubleArray that = (DoubleArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof DoubleArray) {
+                DoubleArray that = (DoubleArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -1412,8 +1480,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            char[] s = source.$array();
-            return (a,b)->{ array[a]=s[b]; };
+            if (source.$array() instanceof char[]) {
+                char[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (char) source.get(b);
+            }
         }
         
         @Override
@@ -1453,15 +1525,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            CharacterArray that = (CharacterArray)values;
-            return (a,b) -> Character.compare(this.array[a], that.array[b]);
+            if(values instanceof CharacterArray) {
+                CharacterArray that = (CharacterArray) values;
+                return (a, b) -> Character.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Character.compare(this.array[a], (char)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            CharacterArray that = (CharacterArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof CharacterArray) {
+                CharacterArray that = (CharacterArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -1525,8 +1605,12 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public NativeMove moveFrom(NativeArray source) {
-            boolean[] s = source.$array();
-            return (a,b) -> array[a]=s[b];
+            if(source.$array() instanceof boolean[]) {
+                boolean[] array = source.$array();
+                return (a, b) -> this.array[a] = array[b];
+            } else {
+                return (a, b) -> array[a] = (boolean) source.get(b);
+            }
         }
         
         @Override
@@ -1566,15 +1650,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            BooleanArray that = (BooleanArray)values;
-            return (a,b) -> Boolean.compare(this.array[a], that.array[b]);
+            if(values instanceof BooleanArray) {
+                BooleanArray that = (BooleanArray) values;
+                return (a, b) -> Boolean.compare(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> Boolean.compare(this.array[a], (boolean)values.get(b));
+            }
         }
 
         @SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            BooleanArray that = (BooleanArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof BooleanArray) {
+                BooleanArray that = (BooleanArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override
@@ -1676,15 +1768,23 @@ public abstract class NativeArray implements Swapper, Comparable<NativeArray>, C
         
         @Override
         public IntComparator comparator(NativeArray values) {
-            ObjectArray that = (ObjectArray)values;
-            return (a,b) -> CompareUtils.cmp(this.array[a], that.array[b]);
+            if(values instanceof ObjectArray) {
+                ObjectArray that = (ObjectArray) values;
+                return (a, b) -> CompareUtils.cmp(this.array[a], that.array[b]);
+            } else {
+                return (a, b) -> CompareUtils.cmp(this.array[a], values.get(b));
+            }
         }
 
 		@SuppressWarnings("unchecked")
         @Override
         public IntComparator comparator(NativeArray values, Comparator cmp) {
-            ObjectArray that = (ObjectArray)values;
-            return (a,b) -> cmp.compare(this.array[a], that.array[b]);
+            if(values instanceof ObjectArray) {
+                ObjectArray that = (ObjectArray) values;
+                return (a, b) -> cmp.compare(this.array[a], that.array[b]);
+            } else {
+                return (a,b) -> cmp.compare(this.array[a], values.get(b));
+            }
         }
         
         @Override