// UV_WRITE is for TCP write. UDP would require a different request type.
internal WriteRequest()
// allocate base NativeHandle with size of UV_WRITE + BufferSize
: base(HandleSize + BufferSize)
{
if (BufferSize >= 0)
{
// pin request handle
// Note: WriteRequest is pooled. pinning doesn't happen in HOT PATH!
// TODO why does this need to be pinned? (maybe because uv_buf_t*?)
IntPtr HandleAddress = Handle;
Bufs = (uv_buf_t *)(HandleAddress + HandleSize);
pin = GCHandle.Alloc(HandleAddress, GCHandleType.Pinned);
// pin the data array once and keep it pinned until the end.
// no need to unpin before returning to pool and pin again in
// Prepare like we did originally.
// => data is always same size
// => pinning only once is faster
dataPin = GCHandle.Alloc(data, GCHandleType.Pinned);
dataPinAddress = dataPin.AddrOfPinnedObject();
}
else
{
throw new ArgumentException($"BufferSize {BufferSize} needs to be >=0");
}
}
internal void Free()
{
// release pinned request handle
if (pin.IsAllocated)
{
pin.Free();
}
// release pinned data array
if (dataPin.IsAllocated)
{
dataPin.Free();
dataPinAddress = IntPtr.Zero;
}
Bufs = (uv_buf_t *)IntPtr.Zero;
}
unsafe public static extern int uv_write2(UvRequest req,UvStreamHandle handle,uv_buf_t*bufs,int nbufs,UvStreamHandle sendHandle,uv_write_cb cb);
unsafe public void write(UvRequest req, UvStreamHandle handle, uv_buf_t *bufs, int nbufs, uv_write_cb cb)
{
req.Validate();
handle.Validate();
Check(_uv_write(req, handle, bufs, nbufs, cb));
}
unsafe public void write2(UvRequest req, UvStreamHandle handle, uv_buf_t *bufs, int nbufs, UvStreamHandle sendHandle, uv_write_cb cb)
{
req.Validate();
handle.Validate();
ThrowIfErrored(_uv_write2(req, handle, bufs, nbufs, sendHandle, cb));
}
unsafe private int UvWrite(UvRequest req, UvStreamHandle handle, uv_buf_t *bufs, int nbufs, uv_write_cb cb)
{
return(OnWrite(handle, nbufs, status => cb(req.InternalGetHandle(), status)));
}
public static extern unsafe int uv_write(UvRequest req,UvStreamHandle handle,uv_buf_t*bufs,int nbufs,uv_write_cb cb);
unsafe public static extern int uv_write(UVWriteRequest req, UVStreamHandle handle, uv_buf_t *bufs, int nbufs, uv_write_cb cb);
public unsafe static void write(UVWriteRequest req, UVStreamHandle handle, uv_buf_t *bufs, int nbufs, uv_write_cb cb)
{
req.Validate();
handle.Validate();
ThrowIfErrored(uv_write(req, handle, bufs, nbufs, cb));
}
static extern unsafe int uv_write(IntPtr req, IntPtr handle, uv_buf_t *bufs, int nbufs, uv_watcher_cb cb);
// Write data to stream. Buffers are written in order.
// Note: The memory pointed to by the buffers must remain valid until the callback gets called.
internal static unsafe void WriteStream(IntPtr requestHandle, IntPtr streamHandle, uv_buf_t *bufs, int size, uv_watcher_cb write_callback)
{
if (requestHandle != IntPtr.Zero && streamHandle != IntPtr.Zero)
{
int result = uv_write(requestHandle, streamHandle, bufs, size, write_callback);
ThrowIfError(result);
}
else
{
throw new ArgumentException("requestHandle and streamHandle can't be null!");
}
}
private static unsafe extern int uv_write2(IntPtr req, IntPtr handle, uv_buf_t *bufs, int nbufs, IntPtr sendHandle, uv_watcher_cb cb);
internal static unsafe void WriteStream(IntPtr requestHandle, IntPtr streamHandle, uv_buf_t *bufs, ref int size, IntPtr sendHandle)
{
Debug.Assert(requestHandle != IntPtr.Zero);
Debug.Assert(streamHandle != IntPtr.Zero);
Debug.Assert(sendHandle != IntPtr.Zero);
int result = uv_write2(requestHandle, streamHandle, bufs, size, sendHandle, WriteRequest.WriteCallback);
ThrowIfError(result);
}
unsafe private int UvWrite(UvRequest req, UvStreamHandle handle, uv_buf_t *bufs, int nbufs, uv_write_cb cb)
{
return(_onWrite(handle, new ArraySegment <ArraySegment <byte> >(), status => cb(req.InternalGetHandle(), status)));
}
