Package Torello.Java.JSON

Class RJArrDimN

java.lang.Object

Torello.Java.JSON.RJArrDimN

public class RJArrDimN
extends java.lang.Object

RJArrIntoDimN 🠞

• RJArr - Read JsonArray
  This class is used for reading data directly from an already parsed JsonArray instance.
  
  
• DimN - Data is sent to a Multi-Dimensional, User-Specified, Java-Array.

Parses Multi-Dimensional JSON Array's into Multi-Dimensional Java Array's.

This class builds on the J2EE Standard 'Glass-Fish' JSON Processor

There are several JSON Parsers available, and even more implementations for serializing and de-serializing data to/from JSON. The tool included in the J2EE is available on GitHub, and that is the one used by the Java HTML JAR Library. (See: javax.json.* )

Primary Classes Used: JsonArray and JsonObject


This class offers a straightforward way to convert Multi-Dimensional JsonArray instances into Multi-Dimensional Java-Arrays. It is only required that the actual final class of the desired output array be provided as input to the method that shall perform this processing.

JSON Binding Helper-Class:
JSON-Binding is the art of converting data that has been stored, saved or transmitted using Java-Script Object Notation into a Primitive-Type or Object-Type of any Programming Language, for instance Java. JSON often arrives into Java-Program Memory from an external Internet Connection, and may have traveled hundreds or even thousands of miles from a Host-Server.

Unlike Java-Types which are checked by the Java-Compiler each-and-every time a programmer compiles his project, any guarantee that JSON-Type Data is pristine, uncorrupted, and in any kind of pre-agreed format is never completely assured.

Being able to handle changes that might be made to an API (possibly from great distances away, and without the Software-Manager's consent) is the type of feature that robust JSON-Code simply has to offer.


Binding-Helper Features:

• Utilizes the Java-Standard javax.json.* Package-Library, & its Glass-Fish Implementation
• Handles the Transfer & Conversion of All Json-Type's into Java-Type's with just One Line of Code
• Provides all manner of User-Configurable Exception-Handling & Error-Decision Management via Class JFlag
• Provides a Fine-Grained Suite of Exception-Classes, all with Consistent & Meaningful Error-Messages
• Primary Helper-Classes for the (Experimental) Google-Chrome Headless Browser Package

The class allows a user to extract any Java array-type (including Primitive-Arrays) having any number of dimensions for the array, from a JsonArray.


JSON-Array Types:
JsonArray's are allowed quite a bit of leeway in how their data is arranged. First, a JsonArray isn't required to contain a single type of data object. An array may have a JsonString followed by three JsonNumber's, and end with another JsonArray. Java does not allow such array types.

In Java, for instance, a two-dimensional String-Array may only have actual String-references in the second-dimensional arrays! The first-dimension of the array must contain String[] array pointers, or nulls. A JsonArray could contain several String's follwed by another, nested, JsonArray of String's. Care must be taken in how to handle such parses so that the data is parsed properly, and that the output would adhere to standard Java Array-Type "rules" (for lack of a better term).

Here is an example that is perfectly legal in JSON, but simply may not be parsed into any correlated-array in Java. Attempting to use this multi-dimensional array parser on the following JsonArray will cause an exception throw.

Java Script Object Notation (JSON):

{
    "MyValidJsonArray": [ "Hello", "How are You?", ["This", "is", "not", "allowed", "in Java"]]
}

The above example will cause an exception throw if attempting to convert it into a Two-Dimensional String[]-Array. In Java, the first dimension of the array may only contain sub-arrays of type String[]. It is the Second-Dimension that may actually have String-References.

Parsing the above JsonArray would require the programmer to first decide how he wishes to represent the array, and then essentially write a manual conversion algorithm to generate some version of what is above. In leiu of "guessing" what the programmer actually wants done, this type of JsonArray simply cannot be type-transformer class.


IMPORTANT:
In each of the methods in this class, the programmer must provide the return-type that should be returned by that method. The java.lang.Class provided must obey the following specifications:

• The return-type must be an array-type class
• The root component-class of the array must be consistent with the method-name
• The dimensionality of the array must be equal to the variable, field or parameter to which the method result is being assigned.

For instance, to parse a three-dimensional String-Array, one would use the following line of code. Note that the appropriate class is simply obtained by appending '.class' to the end of the String-array. Also note that the variable being assigned (myStrArray) has an identical-type to the type-class passed to this method (String[][]).

Java Line of Code:

String[][] myStrArray = ReadArrJSON.DimN.strArr(someJsonArray, null, 0, String[][].class);

See Also:

Json, JsonArray

Hi-Lited Source-Code:

This File's Source Code:

• View Here: Torello/Java/JSON/RJArrDimN.java
• Open New Browser-Tab: Torello/Java/JSON/RJArrDimN.java

File Size: 28,555 Bytes Line Count: 692 '\n' Characters Found
Build a Settings-Record, Helper Class:

• View Here: BASIC_TYPES.java
• Open New Browser-Tab: BASIC_TYPES.java

File Size: 27,692 Bytes Line Count: 586 '\n' Characters Found
Build a Settings-Record, Helper Class:

• View Here: GENERATE_1DARRAY.java
• Open New Browser-Tab: GENERATE_1DARRAY.java

File Size: 7,907 Bytes Line Count: 241 '\n' Characters Found
Build a Settings-Record, Helper Class:

• View Here: SETTINGS_REC_BUILDER.java
• Open New Browser-Tab: SETTINGS_REC_BUILDER.java

File Size: 6,080 Bytes Line Count: 152 '\n' Characters Found

Stateless Class:

This class neither contains any program-state, nor can it be instantiated. The @StaticFunctional Annotation may also be called 'The Spaghetti Report'. Static-Functional classes are, essentially, C-Styled Files, without any constructors or non-static member fields. It is a concept very similar to the Java-Bean's @Stateless Annotation.

• 1 Constructor(s), 1 declared private, zero-argument constructor
• 18 Method(s), 18 declared static
• 3 Field(s), 3 declared static, 3 declared final

Method Summary

Read a JsonArray into a Multi-Dimensional Object-Array
Modifier and Type	Method
static <RET_ARR_CLASS> RET_ARR_CLASS	objArr(JsonArray ja, Object defaultValue, int FLAGS, Class<RET_ARR_CLASS> retArrClass)
Read a JsonArray into a Multi-Dimensional String-Array
Modifier and Type	Method
static <T> T	strArr(JsonArray ja, String defaultValue, int FLAGS, Class<T> retArrClass)
Read a JsonArray into a Multi-Dimensional Primitive-Array
Modifier and Type	Method
static <T> T	booleanArr(JsonArray ja, boolean defaultValue, int FLAGS, Predicate<String> optionalUserParser, Class<T> retArrClass)
static <T> T	byteArr(JsonArray ja, byte defaultValue, int FLAGS, ToByteFunction<String> optionalUserParser, Class<T> retArrClass)
static <T> T	doubleArr(JsonArray ja, double defaultValue, int FLAGS, ToDoubleFunction<String> optionalUserParser, Class<T> retArrClass)
static <T> T	floatArr(JsonArray ja, float defaultValue, int FLAGS, ToFloatFunction<String> optionalUserParser, Class<T> retArrClass)
static <T> T	intArr(JsonArray ja, int defaultValue, int FLAGS, ToIntFunction<String> optionalUserParser, Class<T> retArrClass)
static <T> T	longArr(JsonArray ja, long defaultValue, int FLAGS, ToLongFunction<String> optionalUserParser, Class<T> retArrClass)
static <T> T	shortArr(JsonArray ja, short defaultValue, int FLAGS, ToShortFunction<String> optionalUserParser, Class<T> retArrClass)
Read a JsonArray into a Multi-Dimensional Boxed-Primitive Array
Modifier and Type	Method
static <T> T	arrBOOLEAN(JsonArray ja, boolean defaultValue, int FLAGS, Function<String,Boolean> optionalUserParser, Class<T> retArrClass)
static <T> T	arrBYTE(JsonArray ja, byte defaultValue, int FLAGS, Function<String,Byte> optionalUserParser, Class<T> retArrClass)
static <T> T	arrDOUBLE(JsonArray ja, double defaultValue, int FLAGS, Function<String,Double> optionalUserParser, Class<T> retArrClass)
static <T> T	arrFLOAT(JsonArray ja, float defaultValue, int FLAGS, Function<String,Float> optionalUserParser, Class<T> retArrClass)
static <T> T	arrINTEGER(JsonArray ja, int defaultValue, int FLAGS, Function<String,Integer> optionalUserParser, Class<T> retArrClass)
static <T> T	arrLONG(JsonArray ja, long defaultValue, int FLAGS, Function<String,Long> optionalUserParser, Class<T> retArrClass)
static <T> T	arrNumber(JsonArray ja, Number defaultValue, int FLAGS, Function<String,Number> optionalUserParser, Class<T> retArrClass)
static <T> T	arrSHORT(JsonArray ja, short defaultValue, int FLAGS, Function<String,Short> optionalUserParser, Class<T> retArrClass)
Protected, Internal Helper Methods
Modifier and Type	Method
protected static <T> Class<T>	CHECK_ARRAY_CLASS(Class<T> retArrClass, Class<?> expectedRootClass)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

intArr

🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T intArr
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.ToIntFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	An int Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal int-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: int[][] arr = ReadArrJSON.DimN.intArr(jsonArray, -1, 0, null, int[][].class);

longArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T longArr
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.ToLongFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive Long-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A long Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal long-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: long[][] arr = ReadArrJSON.DimN.longArr(jsonArray, -1, 0, null, long[][].class);

doubleArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T doubleArr
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.ToDoubleFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive-Doubles

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A double Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal double-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: double[][] arr = ReadArrJSON.DimN.doubleArr(jsonArray, -1.0, 0, null, double[][].class);

shortArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T shortArr
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             ToShortFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive Short-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A short Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal short-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: short[][] arr = ReadArrJSON.DimN.shortArr(jsonArray, -1, 0, null, short[][].class);

byteArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T byteArr
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             ToByteFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive-Bytes

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A byte Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal byte-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: byte[][] arr = ReadArrJSON.DimN.byteArr(jsonArray, -1, 0, null, byte[][].class);

floatArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T floatArr
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             ToFloatFunction<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive-Floats

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A float Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal float-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: float[][] arr = ReadArrJSON.DimN.floatArr(jsonArray, -1.0f, 0, null, float[][].class);

booleanArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T booleanArr
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Predicate<java.lang.String> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Primitive-Booleans

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A boolean Configurations / SettingsRec
Removes:	Any JFlag masks which might insert null-entries in the return-stream
See:	Class JFlag for information about parameter 'FLAGS'
See:	Flag JFlag.NOT_ALLOWED_RET_NULL_MASKS for a list of all disallowed & filtered flags.
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal boolean-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: boolean[][] arr = ReadArrJSON.DimN.booleanArr(jsonArray, false, 0, null, boolean[][].class);

arrINTEGER

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrINTEGER
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Integer> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	An Integer Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Integer-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Integer[][] arr = ReadArrJSON.DimN.arrINTEGER(jsonArray, -1, 0, null, Integer[][].class);

arrLONG

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrLONG
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Long> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed Long-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Long Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Long-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Long[][] arr = ReadArrJSON.DimN.arrLONG(jsonArray, -1, 0, null, Long[][].class);

arrDOUBLE

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrDOUBLE
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Double> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed-Doubles

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Double Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Double-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Double[][] arr = ReadArrJSON.DimN.arrDOUBLE(jsonArray, -1.0, 0, null, Double[][].class);

arrSHORT

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrSHORT
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Short> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed Short-Integers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Short Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Short-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Short[][] arr = ReadArrJSON.DimN.arrSHORT(jsonArray, -1, 0, null, Short[][].class);

arrBYTE

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrBYTE
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Byte> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed-Bytes

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Byte Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Byte-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Byte[][] arr = ReadArrJSON.DimN.arrBYTE(jsonArray, -1, 0, null, Byte[][].class);

arrFLOAT

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrFLOAT
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Float> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed-Floats

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Float Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Float-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Float[][] arr = ReadArrJSON.DimN.arrFLOAT(jsonArray, -1.0f, 0, null, Float[][].class);

arrBOOLEAN

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrBOOLEAN
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Boolean> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Boxed-Booleans

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Boolean Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Boolean-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Boolean[][] arr = ReadArrJSON.DimN.arrBOOLEAN(jsonArray, false, 0, null, Boolean[][].class);

arrNumber

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T arrNumber
            (JsonArray ja,
             java.lang.Number defaultValue,
             int FLAGS,
             java.util.function.Function<java.lang.String,java.lang.Number> optionalUserParser,
             java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Best-Fit Boxed-Numbers

Invokes:	Method ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	A Number Configurations / SettingsRec
See:	Class JFlag for information about parameter 'FLAGS'
Note:	The 'Type' of Parameter retArrClass must be a multi-dimensinal Number-Array Type.
	(Notice the "return-type" parameter which is passed in the example below)
Java Line of Code: Number[][] arr = ReadArrJSON.DimN.arrNumber(jsonArray, 0, 0, null, Number[][].class);

strArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <T> T strArr(JsonArray ja,
                           java.lang.String defaultValue,
                           int FLAGS,
                           java.lang.Class<T> retArrClass)

Multi-Dimensional Array of Strings

Invokes:	ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	String Configurations / SettingsRec
See:	Class JFlag for more information about parameter 'FLAGS'.
Note:	retArrClass must be a multi-dimensinal String-array.
	(See last "return-type" parameter in example below)
Java Line of Code: String[][] arr = ReadArrJSON.DimN.strArr(jsonArray, null, 0, String[][].class);

objArr

🡅 🡇 ⇈ ⮫ External-Java: ⮫ ⮫ ⮫ 🗕 🗗 🗖

public static <RET_ARR_CLASS> RET_ARR_CLASS objArr
            (JsonArray ja,
             java.lang.Object defaultValue,
             int FLAGS,
             java.lang.Class<RET_ARR_CLASS> retArrClass)

Multi-Dimensional Array of Object <T>

Invokes:	ProcessMultiDimJsonArray.jsonArrayToJava(JsonArray, SettingsRec, Class)
Passes:	Object Configurations / SettingsRec
See:	class JFlag for more information about parameter 'FLAGS'.
Note:	retArrClass must be a multi-dimensinal Object-array.
	(See last "return-type" parameter in example below)
Java Line of Code: MyClass[][] arr = ReadArrJSON.DimN.strArr(jsonArray, null, 0, MyClass[][].class);

CHECK_ARRAY_CLASS

🡅 ⇈ ⮫ 🗕 🗗 🗖

protected static <T> java.lang.Class<T> CHECK_ARRAY_CLASS
            (java.lang.Class<T> retArrClass,
             java.lang.Class<?> expectedRootClass)

Check user input, and throws exceptions if the array-class has not been properly chosen.

Parameters:

retArrClass - This must be a primitive-array class, possibly of multiple dimensions

expectedRootClass - The expected "root class". For int[][].class, the root class would be int.class.

Returns:

Parameter retArrClass is the return value of this checker method

Throws:

IllegalArgumentExcetion - If parameter retArrClass: If calling retArrClass.isArray() returns FALSE If the root-array type is not the appropriate type for the method that was called