internal static unsafe bool PollSingle(
ZSocket socket,
ZPollItem item, ZPollEvent pollEvents,
out ZError error, TimeSpan?timeout = null)
{
error = default(ZError);
bool result = false;
int timeoutMs = !timeout.HasValue ? -1 : (int)timeout.Value.TotalMilliseconds;
zmq_pollitem_windows_t *native = stackalloc zmq_pollitem_windows_t[1];
// fixed (zmq_pollitem_windows_t* native = managedArray) {
native->SocketPtr = socket.SocketPtr;
native->Events = (short)(item.Events & pollEvents);
native->ReadyEvents = (short)ZPollEvent.None;
while (!(result = (-1 != zmq.poll(native, 1, timeoutMs))))
{
error = ZError.GetLastErr();
/* if (error == ZmqError.EINTR)
* {
* error = default(ZmqError);
* continue;
* } */
break;
}
item.ReadyEvents = (ZPollEvent)native->ReadyEvents;
// }
return(result);
}
public zmq_pollitem_posix_t(IntPtr socket, ZPollEvent pollEvents)
{
if (socket == IntPtr.Zero)
{
throw new ArgumentException("Expected a valid socket handle.", nameof(socket));
}
SocketPtr = socket;
FileDescriptor = 0;
Events = (short)pollEvents;
ReadyEvents = (short)ZPollEvent.None;
}
public static bool Poll(this ZSocket socket, ZPollItem item, ZPollEvent pollEvents, ref ZMessage message, out ZError error, TimeSpan?timeout = null)
{
if (PollSingle(socket, item, pollEvents, out error, timeout))
{
if (PollSingleResult(socket, item, pollEvents, ref message))
{
return(true);
}
error = ZError.EAGAIN;
}
return(false);
}
internal static unsafe bool PollMany(
IEnumerable <ZSocket> sockets,
IEnumerable <ZPollItem> items, ZPollEvent pollEvents,
out ZError error, TimeSpan?timeout = null)
{
error = default(ZError);
bool result = false;
int count = items.Count();
int timeoutMs = !timeout.HasValue ? -1 : (int)timeout.Value.TotalMilliseconds;
zmq_pollitem_windows_t *natives = stackalloc zmq_pollitem_windows_t[count];
// fixed (zmq_pollitem_windows_t* natives = managedArray) {
for (int i = 0; i < count; ++i)
{
ZSocket socket = sockets.ElementAt(i);
ZPollItem item = items.ElementAt(i);
zmq_pollitem_windows_t *native = natives + i;
native->SocketPtr = socket.SocketPtr;
native->Events = (short)(item.Events & pollEvents);
native->ReadyEvents = (short)ZPollEvent.None;
}
while (!(result = (-1 != zmq.poll(natives, count, timeoutMs))))
{
error = ZError.GetLastErr();
// No Signalling on Windows
/* if (error == ZmqError.EINTR) {
* error = ZmqError.DEFAULT;
* continue;
* } */
break;
}
for (int i = 0; i < count; ++i)
{
ZPollItem item = items.ElementAt(i);
zmq_pollitem_windows_t *native = natives + i;
item.ReadyEvents = (ZPollEvent)native->ReadyEvents;
}
// }
return(result);
}
/// <summary>
/// 准备
/// </summary>
/// <param name="sockets"></param>
/// <param name="events"></param>
public void Prepare(ZPollEvent events, params ZSocket[] sockets)
{
Sockets = sockets;
error = null;
Size = sockets.Length;
Ptr = DispoIntPtr.Alloc(sizeof(zmq_pollitem_windows_t) * sockets.Length);
zmq_pollitem_windows_t *natives = (zmq_pollitem_windows_t *)Ptr.Ptr;
for (int i = 0; i < Size; ++i)
{
zmq_pollitem_windows_t *native = natives + i;
native->SocketPtr = sockets[i].SocketPtr;
native->Events = (short)(events);
native->ReadyEvents = (short)ZPollEvent.None;
}
}
internal static bool PollSingleResult(ZSocket socket, ZPollItem item, ZPollEvent pollEvents, ref ZMessage message)
{
bool shouldReceive = item.ReceiveMessage != null && ((pollEvents & ZPollEvent.In) == ZPollEvent.In);
bool shouldSend = item.SendMessage != null && ((pollEvents & ZPollEvent.Out) == ZPollEvent.Out);
if (pollEvents == ZPollEvent.In)
{
if (!shouldReceive)
{
throw new InvalidOperationException("No ReceiveMessage delegate set for Poll.In");
}
if (OnReceiveMessage(socket, item, out message))
{
if (!shouldSend)
{
return(true);
}
if (OnSendMessage(socket, item, message))
{
return(true);
}
}
}
else if (pollEvents == ZPollEvent.Out)
{
if (!shouldSend)
{
throw new InvalidOperationException("No SendMessage delegate set for Poll.Out");
}
if (OnSendMessage(socket, item, message))
{
if (!shouldReceive)
{
return(true);
}
if (OnReceiveMessage(socket, item, out message))
{
return(true);
}
}
}
return(false);
}
public ZPollItem(ZPollEvent events)
{
Events = events;
}
internal static bool PollManyResult(IEnumerable <ZSocket> sockets, IEnumerable <ZPollItem> items, ZPollEvent pollEvents, ref ZMessage[] messages)
{
int count = items.Count();
int readyCount = 0;
bool send = messages != null && ((pollEvents & ZPollEvent.Out) == ZPollEvent.Out);
bool receive = ((pollEvents & ZPollEvent.In) == ZPollEvent.In);
ZMessage[] incoming = null;
if (receive)
{
incoming = new ZMessage[count];
}
for (int i = 0; i < count; ++i)
{
ZSocket socket = sockets.ElementAt(i);
ZPollItem item = items.ElementAt(i);
ZMessage message = send ? messages[i] : null;
if (PollSingleResult(socket, item, pollEvents, ref message))
{
++readyCount;
}
if (receive)
{
incoming[i] = message;
}
}
if (receive)
{
messages = incoming;
}
return(readyCount > 0);
}
public static bool Poll(this IEnumerable <ZSocket> sockets, IEnumerable <ZPollItem> items, ZPollEvent pollEvents, ref ZMessage[] messages, out ZError error, TimeSpan?timeout = null)
{
if (PollMany(sockets, items, pollEvents, out error, timeout))
{
if (PollManyResult(sockets, items, pollEvents, ref messages))
{
return(true);
}
error = ZError.EAGAIN;
}
return(false);
}
