Flattener (mps_java_client 1.1.1 API)

java.lang.Object
- com.mathworks.mps.client.internal.Flattener

```
public class Flattener
extends Object
```
This class contains the logic for flattening of multi-dimensional JAVA (row-major) arrays into column-major 1-dimensional array. The conversion is done in such a manner that if the destination array is curled up into an array with the same dimensions as the input array, a given set of indices will give the same element from both input and output arrays. This class contains various overloads of flatten function for strings, JAVA primitive and boxed types. For each type, there are 4 overloaded flatten methods which are provided as convenience methods. e.g for int we have: flatten(int); flatten(int[]); flatten(int[][]); flatten(int[][][]); For arrays with dimensions greater than 3, all the JAVA types use a common flatten method: flatten(Object); This overload of flatten method internally calls a type specific genericFlatten method. e.g for array of type int of dimension greater than 3, flatten(object) will call following method: genericFlattenInt(int[] dst, Object src, int start, List stride, List len, int depth);

Constructor Summary

Constructors
Constructor and Description

Flattener()

Constructors
Constructor and Description
`Flattener()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[]`	`flatten(boolean src)` Flatten a scalar boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(Boolean src)` Flatten a scalar java.lang.Boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(boolean[] src)` Flatten a 1-dimensional array of boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(Boolean[] src)` Flatten a 1-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(boolean[][] src)` Flatten a 2-dimensional array of boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(Boolean[][] src)` Flatten a 2-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(boolean[][][] src)` Flatten a 3-dimensional array of boolean into a 1-dimensional array of boolean
`static boolean[]`	`flatten(Boolean[][][] src)` Flatten a 3-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
`static byte[]`	`flatten(byte src)` Flatten a scalar byte into a 1-dimensional array of byte
`static byte[]`	`flatten(Byte src)` Flatten a scalar java.lang.Byte into a 1-dimensional array of byte
`static byte[]`	`flatten(byte[] src)` Flatten a 1-dimensional array of byte into a 1-dimensional array of byte
`static byte[]`	`flatten(Byte[] src)` Flatten a 1-dimensional array of java.lang.Byte into a 1-dimensional array of byte
`static byte[]`	`flatten(byte[][] src)` Flatten a 2-dimensional array of byte into a 1-dimensional array of byte
`static byte[]`	`flatten(Byte[][] src)` Flatten a 2-dimensional array of java.lang.Byte into a 1-dimensional array of byte
`static byte[]`	`flatten(byte[][][] src)` Flatten a 3-dimensional array of byte into a 1-dimensional array of byte
`static byte[]`	`flatten(Byte[][][] src)` Flatten a 3-dimensional array of java.lang.Byte into a 1-dimensional array of byte
`static char[]`	`flatten(char src)` Flatten a scalar char into a 1-dimensional array of char
`static char[]`	`flatten(char[] src)` Flatten a 1-dimensional array of char into a 1-dimensional array of char
`static char[]`	`flatten(char[][] src)` Flatten a 2-dimensional array of char into a 1-dimensional array of char
`static char[]`	`flatten(char[][][] src)` Flatten a 3-dimensional array of char into a 1-dimensional array of char
`static char[]`	`flatten(Character src)` Flatten a scalar java.lang.Character into a 1-dimensional array of char
`static char[]`	`flatten(Character[] src)` Flatten a 1-dimensional array of java.lang.Character into a 1-dimensional array of char
`static char[]`	`flatten(Character[][] src)` Flatten a 2-dimensional array of java.lang.Character into a 1-dimensional array of char
`static char[]`	`flatten(Character[][][] src)` Flatten a 3-dimensional array of java.lang.Character into a 1-dimensional array of char
`static double[]`	`flatten(double src)` Flatten a scalar double into a 1-dimensional array of double
`static double[]`	`flatten(Double src)` Flatten a scalar java.lang.Double into a 1-dimensional array of double
`static double[]`	`flatten(double[] src)` Flatten a 1-dimensional array of double into a 1-dimensional array of double
`static double[]`	`flatten(Double[] src)` Flatten a 1-dimensional array of java.lang.Double into a 1-dimensional array of double
`static double[]`	`flatten(double[][] src)` Flatten a 2-dimensional array of double into a 1-dimensional array of double
`static double[]`	`flatten(Double[][] src)` Flatten a 2-dimensional array of java.lang.Double into a 1-dimensional array of double
`static double[]`	`flatten(double[][][] src)` Flatten a 3-dimensional array of double into a 1-dimensional array of double
`static double[]`	`flatten(Double[][][] src)` Flatten a 3-dimensional array of java.lang.Double into a 1-dimensional array of double
`static float[]`	`flatten(float src)` Flatten a scalar float into a 1-dimensional array of float
`static float[]`	`flatten(Float src)` Flatten a scalar java.lang.Float into a 1-dimensional array of float
`static float[]`	`flatten(float[] src)` Flatten a 1-dimensional array of float into a 1-dimensional array of float
`static float[]`	`flatten(Float[] src)` Flatten a 1-dimensional array of java.lang.Float into a 1-dimensional array of float
`static float[]`	`flatten(float[][] src)` Flatten a 2-dimensional array of float into a 1-dimensional array of float
`static float[]`	`flatten(Float[][] src)` Flatten a 2-dimensional array of java.lang.Float into a 1-dimensional array of float
`static float[]`	`flatten(float[][][] src)` Flatten a 3-dimensional array of float into a 1-dimensional array of float
`static float[]`	`flatten(Float[][][] src)` Flatten a 3-dimensional array of java.lang.Float into a 1-dimensional array of float
`static int[]`	`flatten(int src)` Flatten a scalar int into a 1-dimensional array of int
`static int[]`	`flatten(int[] src)` Flatten a 1-dimensional array of int into a 1-dimensional array of int
`static int[]`	`flatten(int[][] src)` Flatten a 2-dimensional array of int into a 1-dimensional array of int
`static int[]`	`flatten(int[][][] src)` Flatten a 3-dimensional array of int into a 1-dimensional array of int
`static int[]`	`flatten(Integer src)` Flatten a scalar java.lang.Integer into a 1-dimensional array of int
`static int[]`	`flatten(Integer[] src)` Flatten a 1-dimensional array of java.lang.Integer into a 1-dimensional array of int
`static int[]`	`flatten(Integer[][] src)` Flatten a 2-dimensional array of java.lang.Integer into a 1-dimensional array of int
`static int[]`	`flatten(Integer[][][] src)` Flatten a 3-dimensional array of java.lang.Integer into a 1-dimensional array of int
`static long[]`	`flatten(long src)` Flatten a scalar long into a 1-dimensional array of long
`static long[]`	`flatten(Long src)` Flatten a scalar java.lang.Long into a 1-dimensional array of long
`static long[]`	`flatten(long[] src)` Flatten a 1-dimensional array of long into a 1-dimensional array of long
`static long[]`	`flatten(Long[] src)` Flatten a 1-dimensional array of java.lang.Long into a 1-dimensional array of long
`static long[]`	`flatten(long[][] src)` Flatten a 2-dimensional array of long into a 1-dimensional array of long
`static long[]`	`flatten(Long[][] src)` Flatten a 2-dimensional array of java.lang.Long into a 1-dimensional array of long
`static long[]`	`flatten(long[][][] src)` Flatten a 3-dimensional array of long into a 1-dimensional array of long
`static long[]`	`flatten(Long[][][] src)` Flatten a 3-dimensional array of java.lang.Long into a 1-dimensional array of long
`static Object`	`flatten(Object src)` Generic method for flattening array of dimensions greater than 3.
`static Object[]`	`flatten(Object[] src)` Flatten a 1-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
`static Object[]`	`flatten(Object[][] src)` Flatten a 2-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
`static Object[]`	`flatten(Object[][][] src)` Flatten a 3-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
`static short[]`	`flatten(short src)` Flatten a scalar short into a 1-dimensional array of short
`static short[]`	`flatten(Short src)` Flatten a scalar java.lang.Short into a 1-dimensional array of short
`static short[]`	`flatten(short[] src)` Flatten a 1-dimensional array of short into a 1-dimensional array of short
`static short[]`	`flatten(Short[] src)` Flatten a 1-dimensional array of java.lang.Short into a 1-dimensional array of short
`static short[]`	`flatten(short[][] src)` Flatten a 2-dimensional array of short into a 1-dimensional array of short
`static short[]`	`flatten(Short[][] src)` Flatten a 2-dimensional array of java.lang.Short into a 1-dimensional array of short
`static short[]`	`flatten(short[][][] src)` Flatten a 3-dimensional array of short into a 1-dimensional array of short
`static short[]`	`flatten(Short[][][] src)` Flatten a 3-dimensional array of java.lang.Short into a 1-dimensional array of short
`static char[]`	`flatten(String src)` Flatten a scalar java.lang.String into a 1-dimensional array of char
`static String[]`	`flatten(String[] src)` Flatten a 1-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
`static String[]`	`flatten(String[][] src)` Flatten a 2-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
`static String[]`	`flatten(String[][][] src)` Flatten a 3-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
`static void`	`genericFlattenBoolean(boolean[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of boolean of dimensions greater than 3 into a 1-dimensional array of boolean.
`static void`	`genericFlattenByte(byte[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of byte of dimensions greater than 3 into a 1-dimensional array of byte.
`static void`	`genericFlattenChar(char[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of char of dimensions greater than 3 into a 1-dimensional array of char.
`static void`	`genericFlattenDouble(double[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of double of dimensions greater than 3 into a 1-dimensional array of double.
`static void`	`genericFlattenFloat(float[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of float of dimensions greater than 3 into a 1-dimensional array of float.
`static void`	`genericFlattenInt(int[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of int of dimensions greater than 3 into a 1-dimensional array of int.
`static void`	`genericFlattenJavaLangBoolean(boolean[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Boolean of dimensions greater than 3 into a 1-dimensional array of boolean.
`static void`	`genericFlattenJavaLangByte(byte[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Byte of dimensions greater than 3 into a 1-dimensional array of byte.
`static void`	`genericFlattenJavaLangCharacter(char[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Character of dimensions greater than 3 into a 1-dimensional array of char.
`static void`	`genericFlattenJavaLangDouble(double[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Double of dimensions greater than 3 into a 1-dimensional array of double.
`static void`	`genericFlattenJavaLangFloat(float[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Float of dimensions greater than 3 into a 1-dimensional array of float.
`static void`	`genericFlattenJavaLangInteger(int[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Integer of dimensions greater than 3 into a 1-dimensional array of int.
`static void`	`genericFlattenJavaLangLong(long[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Long of dimensions greater than 3 into a 1-dimensional array of long.
`static void`	`genericFlattenJavaLangObject(Object[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Object of dimensions greater than 3 into a 1-dimensional array of java.lang.Object.
`static void`	`genericFlattenJavaLangShort(short[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.Short of dimensions greater than 3 into a 1-dimensional array of short.
`static void`	`genericFlattenJavaLangString(String[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of java.lang.String of dimensions greater than 3 into a 1-dimensional array of java.lang.String.
`static void`	`genericFlattenLong(long[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of long of dimensions greater than 3 into a 1-dimensional array of long.
`static void`	`genericFlattenShort(short[] dst, Object src, int start, List<Integer> stride, List<Integer> len, int depth)` Flatten an array of short of dimensions greater than 3 into a 1-dimensional array of short.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Flattener
```
public Flattener()
```
- Method Detail
  - flatten
```
public static Object flatten(Object src)
```
    Generic method for flattening array of dimensions greater than 3.
    
    Parameters:
    
    src - Multi dimensional input array
    
    Returns:
    
    Flattened array
  - flatten
```
public static byte[] flatten(byte src)
```
    Flatten a scalar byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - scalar byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(byte[] src)
```
    Flatten a 1-dimensional array of byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 1-dimensional array of byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(byte[][] src)
```
    Flatten a 2-dimensional array of byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 2-dimensional array of byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(byte[][][] src)
```
    Flatten a 3-dimensional array of byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 3-dimensional array of byte
    
    Returns:
    
    1-dimensional array of byte
  - genericFlattenByte
```
public static void genericFlattenByte(byte[] dst,
                                      Object src,
                                      int start,
                                      List<Integer> stride,
                                      List<Integer> len,
                                      int depth)
```
    Flatten an array of byte of dimensions greater than 3 into a 1-dimensional array of byte.
    
    Parameters:
    
    dst - 1-dimensional array of byte contianing the flattened data.
    
    src - Array of byte with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static int[] flatten(Integer src)
```
    Flatten a scalar java.lang.Integer into a 1-dimensional array of int
    
    Parameters:
    
    src - scalar java.lang.Integer
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(Integer[] src)
```
    Flatten a 1-dimensional array of java.lang.Integer into a 1-dimensional array of int
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Integer
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(Integer[][] src)
```
    Flatten a 2-dimensional array of java.lang.Integer into a 1-dimensional array of int
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Integer
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(Integer[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Integer into a 1-dimensional array of int
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Integer
    
    Returns:
    
    1-dimensional array of int
  - genericFlattenJavaLangInteger
```
public static void genericFlattenJavaLangInteger(int[] dst,
                                                 Object src,
                                                 int start,
                                                 List<Integer> stride,
                                                 List<Integer> len,
                                                 int depth)
```
    Flatten an array of java.lang.Integer of dimensions greater than 3 into a 1-dimensional array of int.
    
    Parameters:
    
    dst - 1-dimensional array of int contianing the flattened data.
    
    src - Array of java.lang.Integer with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static long[] flatten(Long src)
```
    Flatten a scalar java.lang.Long into a 1-dimensional array of long
    
    Parameters:
    
    src - scalar java.lang.Long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(Long[] src)
```
    Flatten a 1-dimensional array of java.lang.Long into a 1-dimensional array of long
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(Long[][] src)
```
    Flatten a 2-dimensional array of java.lang.Long into a 1-dimensional array of long
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(Long[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Long into a 1-dimensional array of long
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Long
    
    Returns:
    
    1-dimensional array of long
  - genericFlattenJavaLangLong
```
public static void genericFlattenJavaLangLong(long[] dst,
                                              Object src,
                                              int start,
                                              List<Integer> stride,
                                              List<Integer> len,
                                              int depth)
```
    Flatten an array of java.lang.Long of dimensions greater than 3 into a 1-dimensional array of long.
    
    Parameters:
    
    dst - 1-dimensional array of long contianing the flattened data.
    
    src - Array of java.lang.Long with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static long[] flatten(long src)
```
    Flatten a scalar long into a 1-dimensional array of long
    
    Parameters:
    
    src - scalar long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(long[] src)
```
    Flatten a 1-dimensional array of long into a 1-dimensional array of long
    
    Parameters:
    
    src - 1-dimensional array of long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(long[][] src)
```
    Flatten a 2-dimensional array of long into a 1-dimensional array of long
    
    Parameters:
    
    src - 2-dimensional array of long
    
    Returns:
    
    1-dimensional array of long
  - flatten
```
public static long[] flatten(long[][][] src)
```
    Flatten a 3-dimensional array of long into a 1-dimensional array of long
    
    Parameters:
    
    src - 3-dimensional array of long
    
    Returns:
    
    1-dimensional array of long
  - genericFlattenLong
```
public static void genericFlattenLong(long[] dst,
                                      Object src,
                                      int start,
                                      List<Integer> stride,
                                      List<Integer> len,
                                      int depth)
```
    Flatten an array of long of dimensions greater than 3 into a 1-dimensional array of long.
    
    Parameters:
    
    dst - 1-dimensional array of long contianing the flattened data.
    
    src - Array of long with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static boolean[] flatten(Boolean src)
```
    Flatten a scalar java.lang.Boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - scalar java.lang.Boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(Boolean[] src)
```
    Flatten a 1-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(Boolean[][] src)
```
    Flatten a 2-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(Boolean[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Boolean
    
    Returns:
    
    1-dimensional array of boolean
  - genericFlattenJavaLangBoolean
```
public static void genericFlattenJavaLangBoolean(boolean[] dst,
                                                 Object src,
                                                 int start,
                                                 List<Integer> stride,
                                                 List<Integer> len,
                                                 int depth)
```
    Flatten an array of java.lang.Boolean of dimensions greater than 3 into a 1-dimensional array of boolean.
    
    Parameters:
    
    dst - 1-dimensional array of boolean contianing the flattened data.
    
    src - Array of java.lang.Boolean with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static float[] flatten(Float src)
```
    Flatten a scalar java.lang.Float into a 1-dimensional array of float
    
    Parameters:
    
    src - scalar java.lang.Float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(Float[] src)
```
    Flatten a 1-dimensional array of java.lang.Float into a 1-dimensional array of float
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(Float[][] src)
```
    Flatten a 2-dimensional array of java.lang.Float into a 1-dimensional array of float
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(Float[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Float into a 1-dimensional array of float
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Float
    
    Returns:
    
    1-dimensional array of float
  - genericFlattenJavaLangFloat
```
public static void genericFlattenJavaLangFloat(float[] dst,
                                               Object src,
                                               int start,
                                               List<Integer> stride,
                                               List<Integer> len,
                                               int depth)
```
    Flatten an array of java.lang.Float of dimensions greater than 3 into a 1-dimensional array of float.
    
    Parameters:
    
    dst - 1-dimensional array of float contianing the flattened data.
    
    src - Array of java.lang.Float with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static char[] flatten(String src)
```
    Flatten a scalar java.lang.String into a 1-dimensional array of char
    
    Parameters:
    
    src - scalar java.lang.String
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static String[] flatten(String[] src)
```
    Flatten a 1-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
    
    Parameters:
    
    src - 1-dimensional array of java.lang.String
    
    Returns:
    
    1-dimensional array of java.lang.String
  - flatten
```
public static String[] flatten(String[][] src)
```
    Flatten a 2-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
    
    Parameters:
    
    src - 2-dimensional array of java.lang.String
    
    Returns:
    
    1-dimensional array of java.lang.String
  - flatten
```
public static String[] flatten(String[][][] src)
```
    Flatten a 3-dimensional array of java.lang.String into a 1-dimensional array of java.lang.String
    
    Parameters:
    
    src - 3-dimensional array of java.lang.String
    
    Returns:
    
    1-dimensional array of java.lang.String
  - genericFlattenJavaLangString
```
public static void genericFlattenJavaLangString(String[] dst,
                                                Object src,
                                                int start,
                                                List<Integer> stride,
                                                List<Integer> len,
                                                int depth)
```
    Flatten an array of java.lang.String of dimensions greater than 3 into a 1-dimensional array of java.lang.String.
    
    Parameters:
    
    dst - 1-dimensional array of java.lang.String contianing the flattened data.
    
    src - Array of java.lang.String with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static double[] flatten(Double src)
```
    Flatten a scalar java.lang.Double into a 1-dimensional array of double
    
    Parameters:
    
    src - scalar java.lang.Double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(Double[] src)
```
    Flatten a 1-dimensional array of java.lang.Double into a 1-dimensional array of double
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(Double[][] src)
```
    Flatten a 2-dimensional array of java.lang.Double into a 1-dimensional array of double
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(Double[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Double into a 1-dimensional array of double
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Double
    
    Returns:
    
    1-dimensional array of double
  - genericFlattenJavaLangDouble
```
public static void genericFlattenJavaLangDouble(double[] dst,
                                                Object src,
                                                int start,
                                                List<Integer> stride,
                                                List<Integer> len,
                                                int depth)
```
    Flatten an array of java.lang.Double of dimensions greater than 3 into a 1-dimensional array of double.
    
    Parameters:
    
    dst - 1-dimensional array of double contianing the flattened data.
    
    src - Array of java.lang.Double with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static boolean[] flatten(boolean src)
```
    Flatten a scalar boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - scalar boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(boolean[] src)
```
    Flatten a 1-dimensional array of boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 1-dimensional array of boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(boolean[][] src)
```
    Flatten a 2-dimensional array of boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 2-dimensional array of boolean
    
    Returns:
    
    1-dimensional array of boolean
  - flatten
```
public static boolean[] flatten(boolean[][][] src)
```
    Flatten a 3-dimensional array of boolean into a 1-dimensional array of boolean
    
    Parameters:
    
    src - 3-dimensional array of boolean
    
    Returns:
    
    1-dimensional array of boolean
  - genericFlattenBoolean
```
public static void genericFlattenBoolean(boolean[] dst,
                                         Object src,
                                         int start,
                                         List<Integer> stride,
                                         List<Integer> len,
                                         int depth)
```
    Flatten an array of boolean of dimensions greater than 3 into a 1-dimensional array of boolean.
    
    Parameters:
    
    dst - 1-dimensional array of boolean contianing the flattened data.
    
    src - Array of boolean with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static char[] flatten(Character src)
```
    Flatten a scalar java.lang.Character into a 1-dimensional array of char
    
    Parameters:
    
    src - scalar java.lang.Character
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(Character[] src)
```
    Flatten a 1-dimensional array of java.lang.Character into a 1-dimensional array of char
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Character
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(Character[][] src)
```
    Flatten a 2-dimensional array of java.lang.Character into a 1-dimensional array of char
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Character
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(Character[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Character into a 1-dimensional array of char
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Character
    
    Returns:
    
    1-dimensional array of char
  - genericFlattenJavaLangCharacter
```
public static void genericFlattenJavaLangCharacter(char[] dst,
                                                   Object src,
                                                   int start,
                                                   List<Integer> stride,
                                                   List<Integer> len,
                                                   int depth)
```
    Flatten an array of java.lang.Character of dimensions greater than 3 into a 1-dimensional array of char.
    
    Parameters:
    
    dst - 1-dimensional array of char contianing the flattened data.
    
    src - Array of java.lang.Character with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static byte[] flatten(Byte src)
```
    Flatten a scalar java.lang.Byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - scalar java.lang.Byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(Byte[] src)
```
    Flatten a 1-dimensional array of java.lang.Byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(Byte[][] src)
```
    Flatten a 2-dimensional array of java.lang.Byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Byte
    
    Returns:
    
    1-dimensional array of byte
  - flatten
```
public static byte[] flatten(Byte[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Byte into a 1-dimensional array of byte
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Byte
    
    Returns:
    
    1-dimensional array of byte
  - genericFlattenJavaLangByte
```
public static void genericFlattenJavaLangByte(byte[] dst,
                                              Object src,
                                              int start,
                                              List<Integer> stride,
                                              List<Integer> len,
                                              int depth)
```
    Flatten an array of java.lang.Byte of dimensions greater than 3 into a 1-dimensional array of byte.
    
    Parameters:
    
    dst - 1-dimensional array of byte contianing the flattened data.
    
    src - Array of java.lang.Byte with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static int[] flatten(int src)
```
    Flatten a scalar int into a 1-dimensional array of int
    
    Parameters:
    
    src - scalar int
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(int[] src)
```
    Flatten a 1-dimensional array of int into a 1-dimensional array of int
    
    Parameters:
    
    src - 1-dimensional array of int
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(int[][] src)
```
    Flatten a 2-dimensional array of int into a 1-dimensional array of int
    
    Parameters:
    
    src - 2-dimensional array of int
    
    Returns:
    
    1-dimensional array of int
  - flatten
```
public static int[] flatten(int[][][] src)
```
    Flatten a 3-dimensional array of int into a 1-dimensional array of int
    
    Parameters:
    
    src - 3-dimensional array of int
    
    Returns:
    
    1-dimensional array of int
  - genericFlattenInt
```
public static void genericFlattenInt(int[] dst,
                                     Object src,
                                     int start,
                                     List<Integer> stride,
                                     List<Integer> len,
                                     int depth)
```
    Flatten an array of int of dimensions greater than 3 into a 1-dimensional array of int.
    
    Parameters:
    
    dst - 1-dimensional array of int contianing the flattened data.
    
    src - Array of int with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static char[] flatten(char src)
```
    Flatten a scalar char into a 1-dimensional array of char
    
    Parameters:
    
    src - scalar char
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(char[] src)
```
    Flatten a 1-dimensional array of char into a 1-dimensional array of char
    
    Parameters:
    
    src - 1-dimensional array of char
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(char[][] src)
```
    Flatten a 2-dimensional array of char into a 1-dimensional array of char
    
    Parameters:
    
    src - 2-dimensional array of char
    
    Returns:
    
    1-dimensional array of char
  - flatten
```
public static char[] flatten(char[][][] src)
```
    Flatten a 3-dimensional array of char into a 1-dimensional array of char
    
    Parameters:
    
    src - 3-dimensional array of char
    
    Returns:
    
    1-dimensional array of char
  - genericFlattenChar
```
public static void genericFlattenChar(char[] dst,
                                      Object src,
                                      int start,
                                      List<Integer> stride,
                                      List<Integer> len,
                                      int depth)
```
    Flatten an array of char of dimensions greater than 3 into a 1-dimensional array of char.
    
    Parameters:
    
    dst - 1-dimensional array of char contianing the flattened data.
    
    src - Array of char with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static double[] flatten(double src)
```
    Flatten a scalar double into a 1-dimensional array of double
    
    Parameters:
    
    src - scalar double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(double[] src)
```
    Flatten a 1-dimensional array of double into a 1-dimensional array of double
    
    Parameters:
    
    src - 1-dimensional array of double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(double[][] src)
```
    Flatten a 2-dimensional array of double into a 1-dimensional array of double
    
    Parameters:
    
    src - 2-dimensional array of double
    
    Returns:
    
    1-dimensional array of double
  - flatten
```
public static double[] flatten(double[][][] src)
```
    Flatten a 3-dimensional array of double into a 1-dimensional array of double
    
    Parameters:
    
    src - 3-dimensional array of double
    
    Returns:
    
    1-dimensional array of double
  - genericFlattenDouble
```
public static void genericFlattenDouble(double[] dst,
                                        Object src,
                                        int start,
                                        List<Integer> stride,
                                        List<Integer> len,
                                        int depth)
```
    Flatten an array of double of dimensions greater than 3 into a 1-dimensional array of double.
    
    Parameters:
    
    dst - 1-dimensional array of double contianing the flattened data.
    
    src - Array of double with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static float[] flatten(float src)
```
    Flatten a scalar float into a 1-dimensional array of float
    
    Parameters:
    
    src - scalar float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(float[] src)
```
    Flatten a 1-dimensional array of float into a 1-dimensional array of float
    
    Parameters:
    
    src - 1-dimensional array of float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(float[][] src)
```
    Flatten a 2-dimensional array of float into a 1-dimensional array of float
    
    Parameters:
    
    src - 2-dimensional array of float
    
    Returns:
    
    1-dimensional array of float
  - flatten
```
public static float[] flatten(float[][][] src)
```
    Flatten a 3-dimensional array of float into a 1-dimensional array of float
    
    Parameters:
    
    src - 3-dimensional array of float
    
    Returns:
    
    1-dimensional array of float
  - genericFlattenFloat
```
public static void genericFlattenFloat(float[] dst,
                                       Object src,
                                       int start,
                                       List<Integer> stride,
                                       List<Integer> len,
                                       int depth)
```
    Flatten an array of float of dimensions greater than 3 into a 1-dimensional array of float.
    
    Parameters:
    
    dst - 1-dimensional array of float contianing the flattened data.
    
    src - Array of float with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static short[] flatten(short src)
```
    Flatten a scalar short into a 1-dimensional array of short
    
    Parameters:
    
    src - scalar short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(short[] src)
```
    Flatten a 1-dimensional array of short into a 1-dimensional array of short
    
    Parameters:
    
    src - 1-dimensional array of short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(short[][] src)
```
    Flatten a 2-dimensional array of short into a 1-dimensional array of short
    
    Parameters:
    
    src - 2-dimensional array of short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(short[][][] src)
```
    Flatten a 3-dimensional array of short into a 1-dimensional array of short
    
    Parameters:
    
    src - 3-dimensional array of short
    
    Returns:
    
    1-dimensional array of short
  - genericFlattenShort
```
public static void genericFlattenShort(short[] dst,
                                       Object src,
                                       int start,
                                       List<Integer> stride,
                                       List<Integer> len,
                                       int depth)
```
    Flatten an array of short of dimensions greater than 3 into a 1-dimensional array of short.
    
    Parameters:
    
    dst - 1-dimensional array of short contianing the flattened data.
    
    src - Array of short with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static Object[] flatten(Object[] src)
```
    Flatten a 1-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Object
    
    Returns:
    
    1-dimensional array of java.lang.Object
  - flatten
```
public static Object[] flatten(Object[][] src)
```
    Flatten a 2-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Object
    
    Returns:
    
    1-dimensional array of java.lang.Object
  - flatten
```
public static Object[] flatten(Object[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Object into a 1-dimensional array of java.lang.Object
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Object
    
    Returns:
    
    1-dimensional array of java.lang.Object
  - genericFlattenJavaLangObject
```
public static void genericFlattenJavaLangObject(Object[] dst,
                                                Object src,
                                                int start,
                                                List<Integer> stride,
                                                List<Integer> len,
                                                int depth)
```
    Flatten an array of java.lang.Object of dimensions greater than 3 into a 1-dimensional array of java.lang.Object.
    
    Parameters:
    
    dst - 1-dimensional array of java.lang.Object contianing the flattened data.
    
    src - Array of java.lang.Object with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case
  - flatten
```
public static short[] flatten(Short src)
```
    Flatten a scalar java.lang.Short into a 1-dimensional array of short
    
    Parameters:
    
    src - scalar java.lang.Short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(Short[] src)
```
    Flatten a 1-dimensional array of java.lang.Short into a 1-dimensional array of short
    
    Parameters:
    
    src - 1-dimensional array of java.lang.Short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(Short[][] src)
```
    Flatten a 2-dimensional array of java.lang.Short into a 1-dimensional array of short
    
    Parameters:
    
    src - 2-dimensional array of java.lang.Short
    
    Returns:
    
    1-dimensional array of short
  - flatten
```
public static short[] flatten(Short[][][] src)
```
    Flatten a 3-dimensional array of java.lang.Short into a 1-dimensional array of short
    
    Parameters:
    
    src - 3-dimensional array of java.lang.Short
    
    Returns:
    
    1-dimensional array of short
  - genericFlattenJavaLangShort
```
public static void genericFlattenJavaLangShort(short[] dst,
                                               Object src,
                                               int start,
                                               List<Integer> stride,
                                               List<Integer> len,
                                               int depth)
```
    Flatten an array of java.lang.Short of dimensions greater than 3 into a 1-dimensional array of short.
    
    Parameters:
    
    dst - 1-dimensional array of short contianing the flattened data.
    
    src - Array of java.lang.Short with number of dimensions greater than 3
    
    start - Offset in the destination array corresponding to an element in source array
    
    stride - List containing value of stride for each dimension
    
    len - List containing all the dimensions of the source array
    
    depth - Level of recursion. This valus is used for determining when we reach the base case

Class Flattener

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Flattener

Method Detail

flatten

flatten

flatten

flatten

flatten

genericFlattenByte

flatten

flatten

flatten

flatten

genericFlattenJavaLangInteger

flatten

flatten

flatten

flatten

genericFlattenJavaLangLong

flatten

flatten

flatten

flatten

genericFlattenLong

flatten

flatten

flatten

flatten

genericFlattenJavaLangBoolean

flatten

flatten

flatten

flatten

genericFlattenJavaLangFloat

flatten

flatten

flatten

flatten

genericFlattenJavaLangString

flatten

flatten

flatten

flatten

genericFlattenJavaLangDouble

flatten

flatten

flatten

flatten

genericFlattenBoolean

flatten

flatten

flatten

flatten

genericFlattenJavaLangCharacter

flatten

flatten

flatten

flatten

genericFlattenJavaLangByte

flatten

flatten

flatten

flatten

genericFlattenInt

flatten

flatten

flatten

flatten

genericFlattenChar

flatten

flatten

flatten

flatten

genericFlattenDouble

flatten

flatten