private unsafe void Write(
UvStreamHandle handle,
ReadableBuffer buffer,
Action <UvWriteReq, int, UvException, object> callback,
object state)
{
try
{
var nBuffers = 0;
if (buffer.IsSingleSpan)
{
nBuffers = 1;
}
else
{
foreach (var _ in buffer)
{
nBuffers++;
}
}
var pBuffers = (LibuvFunctions.uv_buf_t *)_bufs;
if (nBuffers > BUFFER_COUNT)
{
// create and pin buffer array when it's larger than the pre-allocated one
var bufArray = new LibuvFunctions.uv_buf_t[nBuffers];
var gcHandle = GCHandle.Alloc(bufArray, GCHandleType.Pinned);
_pins.Add(gcHandle);
pBuffers = (LibuvFunctions.uv_buf_t *)gcHandle.AddrOfPinnedObject();
}
if (nBuffers == 1)
{
var memory = buffer.First;
var memoryHandle = memory.Retain(true);
_handles.Add(memoryHandle);
// Fast path for single buffer
pBuffers[0] = Libuv.buf_init(
(IntPtr)memoryHandle.PinnedPointer,
memory.Length);
}
else
{
var index = 0;
foreach (var memory in buffer)
{
// This won't actually pin the buffer since we're already using pinned memory
var memoryHandle = memory.Retain(true);
_handles.Add(memoryHandle);
// create and pin each segment being written
pBuffers[index] = Libuv.buf_init(
(IntPtr)memoryHandle.PinnedPointer,
memory.Length);
index++;
}
}
_callback = callback;
_state = state;
_uv.write(this, handle, pBuffers, nBuffers, _uv_write_cb);
}
catch
{
_callback = null;
_state = null;
UnpinGcHandles();
throw;
}
}
public LibuvAwaitable <UvWriteReq> WriteAsync(UvStreamHandle handle, ReadableBuffer buffer)
{
Write(handle, buffer, LibuvAwaitable <UvWriteReq> .Callback, _awaitable);
return(_awaitable);
}
public LibuvAwaitable <UvWriteReq> WriteAsync(UvStreamHandle handle, ArraySegment <ArraySegment <byte> > bufs)
{
Write(handle, bufs, LibuvAwaitable <UvWriteReq> .Callback, _awaitable);
return(_awaitable);
}
public static extern int uv_try_write(UvStreamHandle handle,uv_buf_t[] bufs,int nbufs);
public static extern unsafe int uv_write2(UvRequest req,UvStreamHandle handle,uv_buf_t*bufs,int nbufs,UvStreamHandle sendHandle,uv_write_cb cb);
public static extern int uv_read_start(UvStreamHandle handle,uv_alloc_cb alloc_cb,uv_read_cb read_cb);
public static extern int uv_read_stop(UvStreamHandle handle);
public static extern int uv_listen(UvStreamHandle handle,int backlog,uv_connection_cb cb);
public static extern int uv_accept(UvStreamHandle server,UvStreamHandle client);
public void read_stop(UvStreamHandle handle)
{
handle.Validate();
ThrowIfErrored(_uv_read_stop(handle));
}
public unsafe 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));
}
public void read_start(UvStreamHandle handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
{
handle.Validate();
ThrowIfErrored(_uv_read_start(handle, alloc_cb, read_cb));
}
public void accept(UvStreamHandle server, UvStreamHandle client)
{
server.Validate();
client.Validate();
ThrowIfErrored(_uv_accept(server, client));
}
public void listen(UvStreamHandle handle, int backlog, uv_connection_cb cb)
{
handle.Validate();
ThrowIfErrored(_uv_listen(handle, backlog, cb));
}
public LibuvAwaitable <UvWriteReq> WriteAsync(UvStreamHandle handle, in ReadOnlySequence <byte> buffer)
public LibuvAwaitable <UvWriteReq> WriteAsync(UvStreamHandle handle, ReadOnlySequence <byte> buffer)
{
Write(handle, buffer, LibuvAwaitable <UvWriteReq> .Callback, _awaitable);
return(_awaitable);
}