public TR InObjectStreamOutObjectStream <TR>(int type, Action <IBinaryStream> writeAction,
Func <IBinaryStream, IPlatformTargetInternal, TR> readAction, IPlatformTargetInternal arg)
{
PlatformMemoryStream outStream = null;
long outPtr = 0;
PlatformMemoryStream inStream = null;
long inPtr = 0;
try
{
if (writeAction != null)
{
outStream = IgniteManager.Memory.Allocate().GetStream();
writeAction(outStream);
outPtr = outStream.SynchronizeOutput();
}
if (readAction != null)
{
inStream = IgniteManager.Memory.Allocate().GetStream();
inPtr = inStream.MemoryPointer;
}
var res = UU.TargetInObjectStreamOutObjectStream(_target, type,
((PlatformJniTarget)arg).Target, outPtr, inPtr);
if (readAction == null)
{
return(default(TR));
}
inStream.SynchronizeInput();
var target = res == null ? null : new PlatformJniTarget(res, _marsh);
return(readAction(inStream, target));
}
catch (JavaException jex)
{
throw ConvertException(jex);
}
finally
{
try
{
if (inStream != null)
{
inStream.Dispose();
}
}
finally
{
if (outStream != null)
{
outStream.Dispose();
}
}
}
}
/// <summary>
/// Check stream reallocation.
/// </summary>
/// <param name="mem">Memory.</param>
private void CheckStreamReallocate(IPlatformMemory mem)
{
Assert.IsTrue(mem.Capacity >= 256);
int dataLen = 2048 + 13;
Random rand = new Random();
byte[] data = new byte[dataLen];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)rand.Next(0, 255);
}
PlatformMemoryStream stream = mem.Stream();
stream.WriteByteArray(data);
stream.SynchronizeOutput();
Assert.IsTrue(mem.Capacity >= dataLen);
stream.Reset();
stream.SynchronizeInput();
byte[] data0 = stream.ReadByteArray(dataLen);
Assert.AreEqual(data, data0);
}
/** <inheritdoc /> */
public T InObjectStreamOutObjectStream <T>(int type, IPlatformTarget arg,
Action <IBinaryRawWriter> writeAction, Func <IBinaryRawReader, IPlatformTarget, T> readAction)
{
PlatformMemoryStream outStream = null;
long outPtr = 0;
PlatformMemoryStream inStream = null;
long inPtr = 0;
try
{
if (writeAction != null)
{
outStream = IgniteManager.Memory.Allocate().GetStream();
var writer = _marsh.StartMarshal(outStream);
writeAction(writer);
FinishMarshal(writer);
outPtr = outStream.SynchronizeOutput();
}
if (readAction != null)
{
inStream = IgniteManager.Memory.Allocate().GetStream();
inPtr = inStream.MemoryPointer;
}
var res = UU.TargetInObjectStreamOutObjectStream(_target, type, GetTargetPtr(arg), outPtr, inPtr);
if (readAction == null)
{
return(default(T));
}
inStream.SynchronizeInput();
return(readAction(_marsh.StartUnmarshal(inStream), GetPlatformTarget(res)));
}
catch (JavaException jex)
{
throw ConvertException(jex);
}
finally
{
try
{
if (inStream != null)
{
inStream.Dispose();
}
}
finally
{
if (outStream != null)
{
outStream.Dispose();
}
}
}
}
/// <summary>
/// Perform out-in operation.
/// </summary>
/// <param name="type">Operation type.</param>
/// <param name="outAction">Out action.</param>
/// <param name="inAction">In action.</param>
/// <param name="arg">Argument.</param>
/// <returns>Result.</returns>
protected unsafe TR DoOutInOp <TR>(int type, Action <BinaryWriter> outAction,
Func <IBinaryStream, IUnmanagedTarget, TR> inAction, void *arg)
{
PlatformMemoryStream outStream = null;
long outPtr = 0;
PlatformMemoryStream inStream = null;
long inPtr = 0;
try
{
if (outAction != null)
{
outStream = IgniteManager.Memory.Allocate().GetStream();
var writer = _marsh.StartMarshal(outStream);
outAction(writer);
FinishMarshal(writer);
outPtr = outStream.SynchronizeOutput();
}
if (inAction != null)
{
inStream = IgniteManager.Memory.Allocate().GetStream();
inPtr = inStream.MemoryPointer;
}
var res = UU.TargetInObjectStreamOutObjectStream(_target, type, arg, outPtr, inPtr);
if (inAction == null)
{
return(default(TR));
}
inStream.SynchronizeInput();
return(inAction(inStream, res));
}
finally
{
try
{
if (inStream != null)
{
inStream.Dispose();
}
}
finally
{
if (outStream != null)
{
outStream.Dispose();
}
}
}
}
/// <summary>
/// Perform simple out-in operation accepting single argument.
/// </summary>
/// <param name="type">Operation type.</param>
/// <param name="val">Value.</param>
/// <returns>Result.</returns>
protected TR DoOutInOp <T1, TR>(int type, T1 val)
{
using (PlatformMemoryStream outStream = IgniteManager.Memory.Allocate().GetStream())
{
using (PlatformMemoryStream inStream = IgniteManager.Memory.Allocate().GetStream())
{
BinaryWriter writer = _marsh.StartMarshal(outStream);
writer.WriteObject(val);
FinishMarshal(writer);
UU.TargetInStreamOutStream(_target, type, outStream.SynchronizeOutput(), inStream.MemoryPointer);
inStream.SynchronizeInput();
return(Unmarshal <TR>(inStream));
}
}
}
/// <summary>
/// Perform out-in operation.
/// </summary>
/// <param name="type">Operation type.</param>
/// <param name="outAction">Out action.</param>
/// <param name="inAction">In action.</param>
/// <param name="arg">Argument.</param>
/// <returns>Result.</returns>
protected unsafe TR DoOutInOp <TR>(int type, Action <BinaryWriter> outAction, Func <IBinaryStream, TR> inAction, void *arg)
{
using (PlatformMemoryStream outStream = IgniteManager.Memory.Allocate().GetStream())
{
using (PlatformMemoryStream inStream = IgniteManager.Memory.Allocate().GetStream())
{
BinaryWriter writer = _marsh.StartMarshal(outStream);
outAction(writer);
FinishMarshal(writer);
UU.TargetInObjectStreamOutStream(_target, type, arg, outStream.SynchronizeOutput(), inStream.MemoryPointer);
inStream.SynchronizeInput();
return(inAction(inStream));
}
}
}
/// <summary>
/// Perform out-in operation.
/// </summary>
/// <param name="type">Operation type.</param>
/// <param name="outAction">Out action.</param>
/// <param name="inAction">In action.</param>
protected void DoOutInOp(int type, Action <BinaryWriter> outAction, Action <IBinaryStream> inAction)
{
using (PlatformMemoryStream outStream = IgniteManager.Memory.Allocate().GetStream())
{
using (PlatformMemoryStream inStream = IgniteManager.Memory.Allocate().GetStream())
{
BinaryWriter writer = _marsh.StartMarshal(outStream);
outAction(writer);
FinishMarshal(writer);
UU.TargetInStreamOutStream(_target, type, outStream.SynchronizeOutput(), inStream.MemoryPointer);
inStream.SynchronizeInput();
inAction(inStream);
}
}
}
/// <summary>
/// Perform out-in operation.
/// </summary>
/// <param name="type">Operation type.</param>
/// <param name="outAction">Out action.</param>
/// <returns>Result.</returns>
protected TR DoOutInOp <TR>(int type, Action <PortableWriterImpl> outAction)
{
using (PlatformMemoryStream outStream = IgniteManager.Memory.Allocate().Stream())
{
using (PlatformMemoryStream inStream = IgniteManager.Memory.Allocate().Stream())
{
PortableWriterImpl writer = _marsh.StartMarshal(outStream);
outAction(writer);
FinishMarshal(writer);
UU.TargetInStreamOutStream(_target, type, outStream.SynchronizeOutput(), inStream.MemoryPointer);
inStream.SynchronizeInput();
return(Unmarshal <TR>(inStream));
}
}
}