--- /dev/null
+/*******************************************************************************\r
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
+ * in Industry THTH ry.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * VTT Technical Research Centre of Finland - initial API and implementation\r
+ *******************************************************************************/\r
+package org.simantics.utils.datastructures;\r
+\r
+import java.io.PrintStream;\r
+import java.lang.reflect.Array;\r
+import java.util.Arrays;\r
+import java.util.Collections;\r
+import java.util.Iterator;\r
+import java.util.NoSuchElementException;\r
+\r
+/**\r
+ * Multi-dimension array utils.\r
+ * \r
+ * @See {@link Array} related\r
+ * @See {@link Arrays} related\r
+ * @See {@link Collections} related\r
+ * @author Toni Kalajainen (toni.kalajainen@vtt.fi)\r
+ */\r
+public class MultiDimensionArrayUtils {\r
+\r
+ \r
+ /**\r
+ * Print multi-dimension array\r
+ * @param o\r
+ */\r
+ public static void printArrayDeep(Object v, PrintStream out)\r
+ {\r
+ ArrayIterator<Boolean> i = arrayIterator(v, getArrayLengths(v));\r
+ while (i.hasNext())\r
+ System.out.println(Arrays.toString(i.getIndices())+" = "+i.next());\r
+ } \r
+ \r
+ /**\r
+ * Get array length of each dimension of a multi-dimension array.\r
+ * \r
+ * @param value multi-dimension array\r
+ * @return lengths of each dimension\r
+ */\r
+ public static int[] getArrayLengths(Object value)\r
+ { \r
+ int dim = getDimension(value.getClass());\r
+ int result[] = new int[ dim ];\r
+ if (dim==0) return result;\r
+ \r
+ Object o = value;\r
+ for (int i=0; i<dim; i++) \r
+ {\r
+ result[i] = Array.getLength(o);\r
+ if (result[i]==0) break;\r
+ o = Array.get(o, 0);\r
+ }\r
+ \r
+ return result;\r
+ }\r
+ \r
+ /**\r
+ * Get the number of dimensions in a multi-dimension array.\r
+ * \r
+ * @param value multi-dimension array\r
+ * @return the number of dimensions\r
+ */\r
+ public static int getDimension(Class<?> clazz)\r
+ { \r
+ String signature = clazz.getName();\r
+ int dim = 0;\r
+ for (; dim<signature.length(); dim++) \r
+ if (signature.charAt(dim)!='[') break; \r
+ return dim;\r
+ }\r
+ \r
+ \r
+ /**\r
+ * Deep create multi-level array\r
+ * \r
+ * @param componentType component type\r
+ * @param dims dimension lengths\r
+ * @return multi-level array\r
+ */\r
+ public static Object[] createMultiDimArray(Class<?> componentType, int[] dims)\r
+ {\r
+ // Java 1.6.0\r
+ return (Object[]) Array.newInstance(componentType, dims);\r
+ \r
+ /*\r
+ // Older than 1.6.0\r
+ if (dims==null || componentType==null || dims.length==0) throw new IllegalArgumentException();\r
+ if (dims.length==1) \r
+ return Array.newInstance(componentType, dims[0]);\r
+ \r
+ int[][] dimArrays = new int[dims.length][];\r
+ dimArrays[0] = dims;\r
+ for (int j=1; j<dims.length; j++)\r
+ {\r
+ dimArrays[j] = new int[dims.length-j];\r
+ System.arraycopy(dims, 1, dimArrays[j], 0, dims.length-j);\r
+ }\r
+ return _createMultiDimArray(componentType, dimArrays, 0);\r
+ */\r
+ }\r
+/* \r
+ private static Object[] _createMultiDimArray(Class<?> componentType, int[][] dimArrays, int lvl)\r
+ {\r
+ int[] dims = dimArrays[lvl];\r
+ int len = dims[0];\r
+ Object[] result = (Object[]) Array.newInstance(componentType, dims);\r
+ if (lvl<dimArrays.length-1)\r
+ for (int i=0; i<len; i++)\r
+ result[i] = _createMultiDimArray(componentType, dimArrays, lvl+1);\r
+ return result;\r
+ }\r
+*/ \r
+ \r
+ /**\r
+ * Returns the total number of elements in a multi-dimension array\r
+ * \r
+ * @param dims lengths of each dimension\r
+ * @return total number of elements\r
+ */\r
+ public static int getLength(int[] dims)\r
+ {\r
+ int len = dims[0];\r
+ for (int i=1; i<dims.length; i++)\r
+ len *= dims[i];\r
+ return len; \r
+ }\r
+\r
+ /**\r
+ * Get the component type of an array class\r
+ * \r
+ * @param clazz (array) class\r
+ * @return component type\r
+ */\r
+ public static Class<?> getComponentType(Class<?> clazz)\r
+ {\r
+ Class<?> result = clazz;\r
+ while (result.isArray())\r
+ result = result.getComponentType();\r
+ return result;\r
+ }\r
+ \r
+ /**\r
+ * Demux single-dimension array (x[]) to a multi-dimension array (x[][][])\r
+ * \r
+ * @param src single-dimension array\r
+ * @param dims\r
+ * @return multi-dimension array\r
+ */\r
+ public static Object demuxArray(Object src, int[] dims)\r
+ {\r
+ return demuxArray(src, dims, getComponentType(src.getClass()));\r
+ }\r
+\r
+ /**\r
+ * Demux single-dimension array (x[]) to a multi-dimension array (x[][][])\r
+ * \r
+ * @param src single-dimension array\r
+ * @param dims \r
+ * @param componentType\r
+ * @return multi-dimension array\r
+ */\r
+ public static Object demuxArray(Object src, int[] dims, Class<?> componentType)\r
+ {\r
+ Object dst = Array.newInstance(componentType, dims);\r
+ _fillDemux(0, dims, src, 0, dst);\r
+ return dst;\r
+ }\r
+ \r
+ /**\r
+ * Demuxes single dimension array into a multi-dimension array\r
+ * \r
+ * @param src one dimension array (e.g. int[])\r
+ * @param dimensions length of each dimension\r
+ * @param dst multi-dimension array to be filled (use createMultiDimArray())\r
+ */\r
+ public static void demuxArray(Object src, int[] dims, Object dst)\r
+ {\r
+ if (Array.getLength(src) != getLength(dims)) \r
+ throw new IllegalArgumentException("The length of src does not match the length of dst"); \r
+ _fillDemux(0, dims, src, 0, dst);\r
+ }\r
+ \r
+ private static int _fillDemux(int lvl, int[] dims, Object src, int srcIndex, Object dst)\r
+ {\r
+ // lower level\r
+ if (lvl==dims.length-1) {\r
+ int len = dims[dims.length-1]; \r
+ System.arraycopy(src, srcIndex, dst, 0, len);\r
+ return srcIndex + len;\r
+ }\r
+ // higher level\r
+ for (int i=0; i<dims[lvl]; i++)\r
+ srcIndex = _fillDemux(lvl+1, dims, src, srcIndex, Array.get(dst, i));\r
+ \r
+ return srcIndex;\r
+ }\r
+\r
+ /**\r
+ * Multiplex multi-dimension array (x[][][]) to single-dimension array (x[])\r
+ * \r
+ * @param src multi-dimension array\r
+ * @return single-dimension array\r
+ */\r
+ public static Object muxArray(Object src)\r
+ {\r
+ return muxArray(src, getArrayLengths(src), getComponentType(src.getClass()));\r
+ } \r
+ \r
+ /**\r
+ * Multiplex multi-dimension array (x[][][]) to single-dimension array (x[])\r
+ * \r
+ * @param src multi-dimension array\r
+ * @param dims\r
+ * @return single-dimension array\r
+ */\r
+ public static Object muxArray(Object src, int[] dims)\r
+ {\r
+ return muxArray(src, dims, getComponentType(src.getClass()));\r
+ } \r
+ \r
+ /**\r
+ * Multiplex multi-dimension array (x[][][]) to single-dimension array (x[])\r
+ * \r
+ * @param src multi-dimension array\r
+ * @param dims\r
+ * @param componentType\r
+ * @return single-dimension array\r
+ */\r
+ public static Object muxArray(Object src, int[] dims, Class<?> componentType)\r
+ {\r
+ int len = getLength(dims);\r
+ Object dst = Array.newInstance(componentType, len);\r
+ muxArray(src, dims, dst);\r
+ return dst;\r
+ }\r
+ \r
+ /**\r
+ * Multiplexes multi-dimension array into a single-dimension array\r
+ * \r
+ * @param src multi-dimension array\r
+ * @param dims dimensions\r
+ * @param dst single-dimension array\r
+ */\r
+ public static void muxArray(Object src, int[] dims, Object dst)\r
+ {\r
+ int len = getLength(dims);\r
+ if (Array.getLength(dst) != len) \r
+ throw new IllegalArgumentException("The length of src does not match the length of dst");\r
+ \r
+ _fillMux(0, dims, src, dst, 0);\r
+ }\r
+ \r
+ private static int _fillMux(int lvl, int[] dims, Object src, Object dst, int dstIndex)\r
+ {\r
+ if (lvl == dims.length-1)\r
+ {\r
+ int len = dims[lvl];\r
+ System.arraycopy(src, 0, dst, dstIndex, len);\r
+ return dstIndex + len;\r
+ }\r
+ \r
+ for (int i=0; i<dims[lvl]; i++)\r
+ dstIndex += _fillMux(lvl+1, dims, Array.get(src, i), dst, dstIndex);\r
+ \r
+ return 0;\r
+ }\r
+ \r
+ public static <R> ArrayIterator<R> arrayIterator(Object array, int[] dimLens)\r
+ {\r
+ return new ArrayIterator<R>(array, dimLens);\r
+ }\r
+ \r
+ public static class ArrayIterator<T> implements Iterator<T>\r
+ {\r
+ Object v;\r
+ int[] dims;\r
+ int[] indices;\r
+ Object[] arrays;\r
+ int lastIndex, len;\r
+ boolean hasNext = true;\r
+ \r
+ ArrayIterator(Object array, int[] dimLens)\r
+ {\r
+ this.v = array;\r
+ this.dims = dimLens;\r
+ this.indices = new int[dimLens.length];\r
+ this.arrays = new Object[dimLens.length];\r
+ lastIndex = dimLens.length-1;\r
+ @SuppressWarnings("unused")\r
+ int len = dimLens[0];\r
+ for (int i=0; i<=lastIndex; i++)\r
+ if (dimLens[i]==0) hasNext = false;\r
+ for (int i=1; i<=lastIndex; i++) \r
+ len *= dimLens[i];\r
+ arrays[0] = (Object[]) v;\r
+ for (int i=1; i<dimLens.length; i++)\r
+ arrays[i] = ((Object[])arrays[i-1])[0]; \r
+ }\r
+ \r
+ public int[] getIndices()\r
+ {\r
+ return indices; \r
+ }\r
+ \r
+ @Override\r
+ public boolean hasNext() {\r
+ return hasNext;\r
+ }\r
+\r
+ private void _next() {\r
+ int index = lastIndex; \r
+ while (++indices[index] >= dims[index])\r
+ {\r
+ indices[index] = 0;\r
+ index--;\r
+ if (index<0) {\r
+ hasNext = false;\r
+ return;\r
+ }\r
+ arrays[index+1] = ((Object[]) arrays[index])[indices[index]];\r
+ }\r
+ if (index<lastIndex)\r
+ for (int i=index+1; i<=lastIndex; i++)\r
+ arrays[i] = ((Object[])arrays[i-1])[indices[i-1]]; \r
+ }\r
+ \r
+ @SuppressWarnings("unchecked")\r
+ @Override\r
+ public T next() {\r
+ if (!hasNext)\r
+ throw new NoSuchElementException();\r
+ \r
+ T result = (T) Array.get(Array.get(arrays, lastIndex), indices[lastIndex]);\r
+ _next();\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public void remove() {\r
+ throw new UnsupportedOperationException("Cannot remove array element");\r
+ } \r
+ }\r
+\r
+}\r
Code Review / simantics / platform.git / blobdiff