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 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

    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.


    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


    Method Parameters

    Parameter Explanation
    JsonArray ja This may be any parsed JsonArray whose contents are consistent with the Input-Parameters to the User-Provided Consumer 'c'.
    <PRIMITIVE> 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
    int 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.
    To-<PRIMITIVE>
    Function<String>
    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);

      • 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);

      • 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);

      • 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);

      • 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: Like void accept (int jsonArrIndex, int successCount, int value)
         

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

RJArrIntoBoxedConsumer.intArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, short value)
         

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

RJArrIntoBoxedConsumer.shortArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, byte value)
         

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

RJArrIntoBoxedConsumer.byteArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, long value)
         

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

RJArrIntoBoxedConsumer.longArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, double value)
         

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

RJArrIntoBoxedConsumer.doubleArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, float value)
         

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

RJArrIntoBoxedConsumer.floatArr2(ja, -1, 0, null, myConsumer);

      • 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: Like void accept (int jsonArrIndex, int successCount, boolean value)
         

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

RJArrIntoBoxedConsumer.booleanArr2(ja, -1, 0, null, myConsumer);