Package Torello.JSON

Class RJArrIntoPrimConsumer

  • public class RJArrIntoPrimConsumer
extends java.lang.Object
    RJArrIntoPrimConsumer 🠞
    • RJArr - Read JsonArray
      This class is used for reading data directly from an already parsed JsonArray instance.

    • Into - Data that is extracted, is sent to a specific User-Provided Destination.

    • PrimConsumer - Data is sent to a Java Primitive-Consumer.
    Utilities for parsing Json Array's and sending the parsed values into a Java Consumer of Boxed-Primitives.

    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.


    Extract Elements from a JsonArray, and transmit them to Java Primitive-Type Consumer's

    Each of the methods in this class, all declared 'static', accept a standard JsonArray as input, and make a (User-Specified) "Best Efforts" attempt to convert each of the elements of the array into Java-Primitives. Each Json-Array Element that is successfully converted into a primitive is subsequently passed to a (User-Provided) Java-Consumer.
    This class is capable of processing 7 of the 8 Java-Primitives that the language makes available. The 'char' type is not accomodated by the Array-Processing Classes in this Json-Package. For each method in this class, the user is expected to provide a single JsonArray as input, along with one of the appropriate & matching Java Primitive-Consumer. For the Primitive-Consumer's which aren't actually provided by the package java.util.function, the ones within package Torello.Java.Function should be supplied, instead.


    Method Parameters

    Parameter Explanation
    ja This may be any parsed JsonArray whose contents are consistent with the Input-Parameters to the User-Provided Consumer '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-Classes.
    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.
    <PRIMITIVE> Consumer c This is the Output-Target to which all retrieved values from the User-Provided JsonArray are sent.
    IntInt-<PRIMITIVE> Consumer c

    The other Consumer-Type which may be provided as input to this class, has a Method-Sigature which also accepts two extra integers. The two extra int-Parameters are a JsonArray-Index, and also an additional 'count'.

    The value of integer 'count' is the number of times the returned consumer has been provided a value.

    Note that there are certain Error-Cases in which a user may request that the contents of an Array-Index be skipped (via JFlag-Value), rather than force an exception throw. This, hopefully, explains why the 'count' may may, from time to time, be different from the Input Array-Index (although, in most scenarios the Array-Index int and the Count int will be identical).
    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
    • 14 Method(s), 14 declared static
    • 0 Field(s)


    • Method Detail

      • intArr

        🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void intArr​
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.ToIntFunction<java.lang.String> optionalUserParser,
             java.util.function.IntConsumer c)
        Java-Consumer which accepts Primitive-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Integer Settings-Record
        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.
        Lambda-Signature: Like void accept (int value)
         

        Example:
        IntConsumer myConsumer = (int primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.intArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Integer, Void>(
         defaultValue,
         FLAGS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsInt,
         BASIC_TYPES.PRIMITIVE_INTEGER()
     )
     .oneArgConsumer(c::accept)
 );

      • shortArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void shortArr​
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             ToShortFunction<java.lang.String> optionalUserParser,
             ShortConsumer c)
        Java-Consumer which accepts Primitive Short-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Short Settings-Record
        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.
        Lambda-Signature: Like void accept (short value)
         

        Example:
        ShortConsumer myConsumer = (short primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.shortArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "ShortConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Short, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsShort,
         BASIC_TYPES.PRIMITIVE_SHORT()
     )
     .oneArgConsumer(c::accept)
 );

      • byteArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void byteArr​
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             ToByteFunction<java.lang.String> optionalUserParser,
             ByteConsumer c)
        Java-Consumer which accepts Primitive-Bytes
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Byte Settings-Record
        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.
        Lambda-Signature: Like void accept (byte value)
         

        Example:
        ByteConsumer myConsumer = (byte primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.byteArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "ByteConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Byte, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsByte,
         BASIC_TYPES.PRIMITIVE_BYTE()
     )
     .oneArgConsumer(c::accept)
 );

      • longArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void longArr​
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.ToLongFunction<java.lang.String> optionalUserParser,
             java.util.function.LongConsumer c)
        Java-Consumer which accepts Primitive Long-Integers
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Long Settings-Record
        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.
        Lambda-Signature: Like void accept (long value)
         

        Example:
        LongConsumer myConsumer = (long primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.longArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "LongConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Long, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsLong,
         BASIC_TYPES.PRIMITIVE_LONG()
     )
     .oneArgConsumer(c::accept)
 );

      • doubleArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void doubleArr​
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.ToDoubleFunction<java.lang.String> optionalUserParser,
             java.util.function.DoubleConsumer c)
        Java-Consumer which accepts Primitive-Doubles
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Double Settings-Record
        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.
        Lambda-Signature: Like void accept (double value)
         

        Example:
        DoubleConsumer myConsumer = (double primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.doubleArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "DoubleConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Double, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsDouble,
         BASIC_TYPES.PRIMITIVE_DOUBLE()
     )
     .oneArgConsumer(c::accept)
 );

      • floatArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void floatArr​
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             ToFloatFunction<java.lang.String> optionalUserParser,
             FloatConsumer c)
        Java-Consumer which accepts Primitive-Floats
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Float Settings-Record
        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.
        Lambda-Signature: Like void accept (float value)
         

        Example:
        FloatConsumer myConsumer = (float primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.floatArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "FloatConsumer parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Float, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsFloat,
         BASIC_TYPES.PRIMITIVE_FLOAT()
     )
     .oneArgConsumer(c::accept)   
 );

      • booleanArr

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void booleanArr​
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Predicate<java.lang.String> optionalUserParser,
             BoolConsumer c)
        Java-Consumer which accepts Primitive-Booleans
        Invokes: Method ProcessJsonArray.booleanToJava(JsonArray, SettingsRec)
        Passes: Java Boolean Settings-Record
        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.
        Lambda-Signature: Like void accept (boolean value)
         

        Example:
        BoolConsumer myConsumer = (boolean primVal) -> System.out.println(primVal);
RJArrIntoBoxedConsumer.booleanArr(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "BoolConsumer parameter 'c' is null");

 ProcessJsonArray.booleanToJava(
     ja,
     new SETTINGS_REC_BUILDER<Boolean, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::test,
         BASIC_TYPES.PRIMITIVE_BOOLEAN()
     )
     .oneArgConsumer(c::accept)   
 );

      • intArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void intArr2​
            (JsonArray ja,
             int defaultValue,
             int FLAGS,
             java.util.function.ToIntFunction<java.lang.String> optionalUserParser,
             TriIntCons c)
        Java-Consumer which accepts Primitive-Integers & Array-Indices
        Invokes:   ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Integer Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface TriIntCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, int value)
         

        Example:
        TriIntCons myConsumer = (int i1, int i2, int primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.intArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "TriIntCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Integer, Void>(
         defaultValue,
         FLAGS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsInt,
         BASIC_TYPES.PRIMITIVE_INTEGER()
     )
     .threeArgConsumer(c::accept)
 );

      • shortArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void shortArr2​
            (JsonArray ja,
             short defaultValue,
             int FLAGS,
             ToShortFunction<java.lang.String> optionalUserParser,
             IntIntShortCons c)
        Java-Consumer which accepts Primitive Short-Integers & Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Short Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntShortCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, short value)
         

        Example:
        IntIntShortCons myConsumer = (int i1, int i2, short primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.shortArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntShortCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Short, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsShort,
         BASIC_TYPES.PRIMITIVE_SHORT()
     )
     .threeArgConsumer(c::accept)
 );

      • byteArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void byteArr2​
            (JsonArray ja,
             byte defaultValue,
             int FLAGS,
             ToByteFunction<java.lang.String> optionalUserParser,
             IntIntByteCons c)
        Java-Consumer which accepts Primitive-Bytes & Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Byte Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntByteCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, byte value)
         

        Example:
        IntIntByteCons myConsumer = (int i1, int i2, byte primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.byteArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntByteCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Byte, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsByte,
         BASIC_TYPES.PRIMITIVE_BYTE()
     )
     .threeArgConsumer(c::accept)
 );

      • longArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void longArr2​
            (JsonArray ja,
             long defaultValue,
             int FLAGS,
             java.util.function.ToLongFunction<java.lang.String> optionalUserParser,
             IntIntLongCons c)
        Java-Consumer which accepts Primitive Long-Integers & Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Long Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntLongCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, long value)
         

        Example:
        IntIntLongCons myConsumer = (int i1, int i2, long primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.longArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntLongCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Long, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsLong,
         BASIC_TYPES.PRIMITIVE_LONG()
     )
     .threeArgConsumer(c::accept)
 );

      • doubleArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void doubleArr2​
            (JsonArray ja,
             double defaultValue,
             int FLAGS,
             java.util.function.ToDoubleFunction<java.lang.String> optionalUserParser,
             IntIntDoubleCons c)
        Java-Consumer which accepts Primitive-Doubles & Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Double Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntDoubleCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, double value)
         

        Example:
        IntIntDoubleCons myConsumer = (int i1, int i2, double primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.doubleArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntDoubleCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Double, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsDouble,
         BASIC_TYPES.PRIMITIVE_DOUBLE()
     )
     .threeArgConsumer(c::accept)
 );

      • floatArr2

        🡅  🡇  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void floatArr2​
            (JsonArray ja,
             float defaultValue,
             int FLAGS,
             ToFloatFunction<java.lang.String> optionalUserParser,
             IntIntFloatCons c)
        Java-Consumer which accepts Primitive-Floats & Array-Indices
        Invokes: Method ProcessJsonArray.numericToJava(JsonArray, SettingsRec)
        Passes: Java Float Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntFloatCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, float value)
         

        Example:
        IntIntFloatCons myConsumer = (int i1, int i2, float primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.floatArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntFloatCons parameter 'c' is null");

 ProcessJsonArray.numericToJava(
     ja,
     new SETTINGS_REC_BUILDER<Float, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::applyAsFloat,
         BASIC_TYPES.PRIMITIVE_FLOAT()
     )
     .threeArgConsumer(c::accept)
 );

      • booleanArr2

        🡅  ⇈  ⮫     External-Java:   ⮫  ⮫ 🗕  🗗  🗖 
        public static void booleanArr2​
            (JsonArray ja,
             boolean defaultValue,
             int FLAGS,
             java.util.function.Predicate<java.lang.String> optionalUserParser,
             IntIntBoolCons c)
        Java-Consumer which accepts Primitive-Booleans & Array-Indices
        Invokes: Method ProcessJsonArray.booleanToJava(JsonArray, SettingsRec)
        Passes: Java Boolean Settings-Record, w/ an "Array-Indices & Count Consumer"
        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.
        Input-Consumer: Interface IntIntBoolCons
        Lambda-Signature: (Functional Interface) void accept (int jsonArrIndex, int acceptCount, boolean value)
         

        Example:
        IntIntBoolCons myConsumer = (int i1, int i2, boolean primVal) ->
    System.out.println("jsonArr[" + i1 + "], acceptCount[" + i2 + "]: " + primVal);

RJArrIntoBoxedConsumer.booleanArr2(ja, -1, 0, null, myConsumer);
        Code:
        Exact Method Body:
         Objects.requireNonNull(c, "IntIntBoolCons parameter 'c' is null");

 ProcessJsonArray.booleanToJava(
     ja,
     new SETTINGS_REC_BUILDER<Boolean, Void>(
         defaultValue,
         FLAGS & NOT_ALLOWED_RET_NULL_MASKS,
         (optionalUserParser == null) ? null : optionalUserParser::test,
         BASIC_TYPES.PRIMITIVE_BOOLEAN()
     )
     .threeArgConsumer(c::accept)
 );