Package Torello.JSON

Class 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 Glass Fish Tool is included in the J2EE, and is available on GitHub. That is the one used by the Java HTML JAR Library (See: javax.json.* )

    Primary Classes Used: JsonArray and JsonObject

    This comment-note is intentionally repeated, verbatim, at the top of all Json Reader Classes in this package.


    JSON to Java Binding:
    JSON-Binding is the art of converting data that has been stored, saved or transmitted using Java-Script Object Notation into a Java Primitive or Object-Type. JSON can arrive into Java-Program Memory from almost any source. If you are wondering why such a massive amount of "work" is necessary just to convert a Json Integer into Java Integer, the value added is the extraordinary amount of attention paid to user configuration, error checking, & exception messaging. Methods here don't require more than 1 or 2 lines of code, and guarantee that a thorough type checking is performed.

    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 may or may not be assured. The methods here are able to handle changes that might be made to an API (possibly from great distances away, and without the Software-Manager's consent). If an error could occur, configuration flags can be used to determine default error-recovery behaviors. If an exception does throw, the exception messages printed will contain multiple lines of detailed information.

    • 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. Json Files can occasionally grow extremely large, and error messaging details make debugging easier
    • Primary Helper-Classes for the (Experimental) Google-Chrome Browser Automation Package

    The goal of Torello.JSON is to provide small, static helper methods in the same spirit as java.util.Objects and java.util.Arrays: simple calls that keep JSON handling out of your application logic. Instead of repeating loops, type checks, null checks, and exception wiring at every call site, these methods centralize that work behind a consistent set of straight-forward “read value” operations.


    Read Multi-Dimensional JsonArray's into Multi-Dimensional Java Arrays

    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.

    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 = RJArrDimN.strArr(someJsonArray, null, 0, String[][].class);


    Method Parameters

    Parameter Explanation
    ja This may be any parsed JsonArray whose contents are consistent with the Expected Output-Array Base-Type returned from whichever method is being invoked. 'c'.
    defaultValue When an appropriate JFlag-Value is included in the mask, this Default-Value will be passed to the User-Provided Consumer in whichever Error-Circumstance has occured (as per the Flag-Value Name).

    This Default-Value may be requested through JFlag-Values such as: RD_AEX, RD_IOB and RD_M (among others). The 'RD' in these Flag's Names is an abbreviation for "Return Default-Value".

    The Complete List of Flags which request that this Default-Value Parameter be employed under various Error-Circumstances may be viewed in the following link. The name of each of these flags attempts identify the type of Error-Situation to which it may be applied.

    Default-Value Flags
    FLAGS A Bit-Wise Flag-Mask that provides a means for configuring the Array-Processing Logic to properly handle several types of Error-Cases & potentatial, unexpected, array contents.

    A Flag-Mask of '0' requests that any Error-Situations which occur, should they crop up while processing the array, be handled by standard means - meaning by throwing one of the germaine Exception-Class.
    optionalUserParser This parameter can only serve a purpose when it is used in conjunction with a JFlag-Vaule which explicity requests that Java String-Values be handled by a parser (rather than causing an exception to throw).

    The two flags which may be employed to signal this Handler-Behavior are: RETURN_PARSE_ON_STR and RP_S (the latter being merely the abbreviated variant of the former).

    If neither of these flags have been AND'ed into the Flag-Mask parameter ("FLAGS"), then any function which is passed to this parameter ("optionalUserParser") is wholly ignored - simply because using a String-Parser is not a "Default Behavior of this class' Array-Processing Logic.
    retArrClass The requested / expected Return-Array Type.

    To extract or retrieve a 2-Dimensional Integer-Array, simply pass int[][].class

    To request a 3-Dimensional String-Array, simply pass String[][][].class
    See Also:
    Json, JsonArray



    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
    • 16 Method(s), 16 declared static
    • 0 Field(s)


    • Method Summary

       
      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)

      • 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 = RJArrDimN.intArr(jsonArray, -1, 0, null, int[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Integer, IntStream>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsInt,
         BASIC_TYPES.PRIMITIVE_INTEGER()
     )
     .dimNArrayIntPrim(),
     retArrClass
 );

      • 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 = RJArrDimN.longArr(jsonArray, -1, 0, null, long[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Long, LongStream>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsLong,
         BASIC_TYPES.PRIMITIVE_LONG()
     )
     .dimNArrayLongPrim(),
     retArrClass
 );

      • 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 = RJArrDimN.doubleArr(jsonArray, -1.0, 0, null, double[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Double, DoubleStream>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,    
         (optionalUserParser == null) ? null : optionalUserParser::applyAsDouble,
         BASIC_TYPES.PRIMITIVE_DOUBLE()
     )
     .dimNArrayDoublePrim(),
     retArrClass
 );

      • 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 = RJArrDimN.shortArr(jsonArray, -1, 0, null, short[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Short, Stream<Short>>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,    
         (optionalUserParser == null) ? null : optionalUserParser::applyAsShort,
         BASIC_TYPES.PRIMITIVE_SHORT()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.byteArr(jsonArray, -1, 0, null, byte[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Byte, Stream<Byte>>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,    
         (optionalUserParser == null) ? null : optionalUserParser::applyAsByte,
         BASIC_TYPES.PRIMITIVE_BYTE()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.floatArr(jsonArray, -1.0f, 0, null, float[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Float, Stream<Float>>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,    
         (optionalUserParser == null) ? null : optionalUserParser::applyAsFloat,
         BASIC_TYPES.PRIMITIVE_FLOAT()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.booleanArr(jsonArray, false, 0, null, boolean[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Boolean, Stream<Boolean>>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,    
         (optionalUserParser == null) ? null : optionalUserParser::test,
         BASIC_TYPES.PRIMITIVE_BOOLEAN()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrINTEGER(jsonArray, -1, 0, null, Integer[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Integer, Stream<Integer>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_INTEGER()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrLONG(jsonArray, -1, 0, null, Long[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Long, Stream<Long>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_LONG()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrDOUBLE(jsonArray, -1.0, 0, null, Double[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Double, Stream<Double>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_DOUBLE()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrSHORT(jsonArray, -1, 0, null, Short[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Short, Stream<Short>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_SHORT()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrBYTE(jsonArray, -1, 0, null, Byte[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Byte, Stream<Byte>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_BYTE()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrFLOAT(jsonArray, -1.0f, 0, null, Float[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Float, Stream<Float>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_FLOAT()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrBOOLEAN(jsonArray, false, 0, null, Boolean[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Boolean, Stream<Boolean>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.BOXED_BOOLEAN()
     )
     .dimNArray(),
     retArrClass
 );

      • 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 = RJArrDimN.arrNumber(jsonArray, 0, 0, null, Number[][].class);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja,
     new SETTINGS_REC_BUILDER<Number, Stream<Number>>(
         defaultValue,
         FLAGS,
         optionalUserParser,
         BASIC_TYPES.NUMBER_REC()
     )
     .dimNArray(),
     retArrClass
 );

      • 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);
        Code:
        Exact Method Body:
         return ProcessMultiDimJsonArray.jsonArrayToJava(
     ja, 
     new SETTINGS_REC_BUILDER<String, Stream<String>>(
         defaultValue,
         FLAGS,
         null, // no optional user parser, input is supposed to be a string
         BASIC_TYPES.STRING_REC()
     )
     .dimNArray(),
     retArrClass
 );