Introduce in JNetReflector ability to use `JCOBridgeStream<T>`

[masesdevelopers]

Is your feature request related to a problem? Please describe.
JCOBridge rc7 contains a great improvement in array management with a zero-copy memory based on JCOBridgeStream<T>; the feature, available around many methods managing native array types, returns a new object able to interact directly within the JVM memory and adds support for Span<T> and ReadOnlySpan<T>.

Describe the solution you'd like
Extends the methods reflected to support the new feature adding, side-by-side, to the current one new methods with Stream trailer which returns JCOBridgeStream<T>; since T has the unmanaged constraint, and internally the type is checked at runtime, the type on JVM shall be checked accordingly.

Describe alternatives you've considered
N/A

Additional context
N/A

[masesdevelopers]

There is a limitation with generics. A type like Map<K, V> may have V that is e.g. byte[] however this case is not deducible from reflection and it becomes concrete when the instance is used. Since the methods are generated starting from the current knowledge isn't possible to declare all possible combination and it is not useful at all: Map<K, V> has two generic type variable with many methods and just for V we have to consider that V can be a class object managed from IExecute<V> and beside something like IExecuteStream<VInner> where VInner is the type of the array VInner[] defined from V with a constraint like where VInner : unmanaged. All of the previous repeat for each occurrence of each type variable.

Since JCOBridgeStream<T> shall be used with some hints, another solution can be the use of the corresponding raw type. JNetReflector, beside every generic, creates the raw type that exposes object instead of the exact type, internally the invocation is a simple IExecute which returns the underlying type: IJavaObject or IJavaArray, then using the Convert extension it is possible to obtain JCOBridgeStream<T> like in the following scratch:

1. Map<K, V>.EntrySet()
2. for each element returns a Java.Util.Map.Entry<K, V> which supports

   JNet/src/net/JNet/Generated/Java/Util/Map.cs

   Line 540 in 74780ef

   public static implicit operator Java.Util.Map.Entry(Java.Util.Map.Entry<K, V> t) => t.Cast<Java.Util.Map.Entry>();

3. An Entry can return the raw value

   JNet/src/net/JNet/Generated/Java/Util/Map.cs

   Lines 505 to 508 in 74780ef

   	public object Value
   	{
   	get { return IExecuteWithSignature("getValue", "()Ljava/lang/Object;"); }
   	}

4. The returned value can be converted to obtain JCOBridgeStream<T>:

Entry entry;
var value = entry.Value;
JCOBridgeStream<byte> = value.Convert<JCOBridgeStream<byte>>();

or in some other cases:

Entry entry;
var value = entry.Value as IJavaArray;
JCOBridgeStream<byte> = value.ToStream<byte>(FileAccess.ReadWrite, true);

It is not a direct availability of JCOBridgeStream<T>, however the context where JCOBridgeStream<T> is used needs attention from user when the code is written: we can pay the code overhead.

[masesdevelopers]

Another limitation is related to the listener/callback: JNetReflector identify the type and if it is a concrete type use it, but listeners come with the same drawback with generics and, as extra, the functions and delegates shall be multiplied or shall be created something like virtual *Raw methods and *Raw delegates.
This is an over engineering of a functionality shall be used with caution; the solution in this case is very simple since all listeners extends JVMBridgeListener and this class exposes two virtual method ListenerShallManageEvent:

• the one with a single parameter is used to early intercept not managed events
• the second one with two parameters can be overrided from the user (or the user can use the delegates) to capture the data information:
  • every listener built with JNetReflector returns data as CLRListenerEventArgs<CLREventData<MASES.JNet.Specific.JNetEventResult>>
  • JNetEventResult gives access to some data associated to the event
  • CLRListenerEventArgs manages directly each parameter sent from the JVM through CLREventData
  • CLREventData returns the JVM parameter as IJavaObject
  • using the IJavaObject at the index of interest it is possible to convert it into an IJavaArray and finally obtain the JCOBridgeStream<T>

A snippet is the following;

protected override bool ListenerShallManageEvent(int eventIndex, object data)
{
    CLRListenerEventArgs<JNetEventResult> result = data as CLRListenerEventArgs<JNetEventResult>;
    CLREventData<MASES.JNet.Specific.JNetEventResult> parameters = result.EventData;

    IJavaObject firstParameter = parameters[0];
    using (firstParameter)
    {
        using IJavaArray array = firstParameter.ToJavaArray();
        using JCOBridgeStream<byte>stream = array.ToStream<byte>();
        // then use stream
    }
}