func (p *Poller) poll(timeout time.Duration, all bool) ([]Polled, error) {
lst := make([]Polled, 0, len(p.items))
for _, soc := range p.socks {
if !soc.opened {
return lst, ErrorSocketClosed
}
}
t := timeout
if t > 0 {
t = t / time.Millisecond
}
if t < 0 {
t = -1
}
rv, err := C.zmq_poll(&p.items[0], C.int(len(p.items)), C.long(t))
if rv < 0 {
return lst, errget(err)
}
for i, it := range p.items {
if all || it.events&it.revents != 0 {
lst = append(lst, Polled{p.socks[i], State(it.revents)})
}
}
return lst, nil
}
// Poll waits for activity on the monitored set of sockets and/or files. If the timeout is zero, Poll will return
// immediately. If it is negative, Poll will wait forever until an event is triggered. Poll returns the number of
// sockets/files for which events were triggered, or a non-nil error.
func (p *PollSet) Poll(timeout time.Duration) (n int, err error) {
if p.items == nil || len(p.items) == 0 {
return
}
started := time.Now()
for {
var micros C.long
if timeout < 0 {
micros = -1
} else {
micros = C.long(started.Add(timeout).Sub(time.Now()) / time.Microsecond)
}
err = nil
r := C.zmq_poll(&p.items[0], C.int(len(p.items)), micros)
if r == -1 {
err = zmqerr()
} else {
n = int(r)
}
if err != ErrInterrupted {
break
}
}
return
}
func (p lzmqContext) Poll(items []PollItem, timeout int) (int, os.Error) {
ret := int(C.zmq_poll((*C.zmq_pollitem_t)(unsafe.Pointer(&items[0])), C.int(len(items)), C.long(timeout)))
if ret >= 0 {
return ret, nil
}
return 0, p.Provider().GetError()
}
// Poll ZmqSockets and file descriptors for I/O readiness. Timeout is in
// microseconds.
func Poll(items []PollItem, timeout int64) (count int, err error) {
zitems := make([]C.zmq_pollitem_t, len(items))
for i, pi := range items {
zitems[i].socket = pi.Socket.apiSocket()
zitems[i].fd = pi.Fd.ToRaw()
zitems[i].events = C.short(pi.Events)
}
rc := int(C.zmq_poll(&zitems[0], C.int(len(zitems)), C.long(timeout)))
if rc == -1 {
return 0, errno()
}
for i, zi := range zitems {
items[i].REvents = PollEvents(zi.revents)
}
return rc, nil
}
/*
Input/output multiplexing
If timeout < 0, wait forever until a matching event is detected
Only sockets with matching socket events are returned in the list.
Example:
poller := zmq.NewPoller()
poller.Add(socket0, zmq.POLLIN)
poller.Add(socket1, zmq.POLLIN)
// Process messages from both sockets
for {
sockets, _ := poller.Poll(-1)
for _, socket := range sockets {
switch s := socket.Socket; s {
case socket0:
msg, _ := s.Recv(0)
// Process msg
case socket1:
msg, _ := s.Recv(0)
// Process msg
}
}
}
*/
func (p *Poller) Poll(timeout time.Duration) ([]Polled, error) {
lst := make([]Polled, 0, p.size)
t := timeout
if t > 0 {
t = t / time.Millisecond
}
if t < 0 {
t = -1
}
rv, err := C.zmq_poll(&p.items[0], C.int(len(p.items)), C.long(t))
if rv < 0 {
return lst, errget(err)
}
for i, it := range p.items {
if it.events&it.revents != 0 {
lst = append(lst, Polled{p.socks[i], State(it.revents)})
}
}
return lst, nil
}
// Poll ZmqSockets and file descriptors for I/O readiness. Timeout is in
// time.Duration. The smallest possible timeout is time.Millisecond for
// ZeroMQ version 3 and above, and time.Microsecond for earlier versions.
func Poll(items []PollItem, timeout time.Duration) (count int, err error) {
zitems := make([]C.zmq_pollitem_t, len(items))
for i, pi := range items {
zitems[i].socket = pi.Socket.apiSocket()
zitems[i].fd = pi.Fd.ToRaw()
zitems[i].events = C.short(pi.Events)
}
ztimeout := C.long(-1)
if timeout >= 0 {
ztimeout = C.long(uint64(timeout / pollunit))
}
rc, err := C.zmq_poll(&zitems[0], C.int(len(zitems)), ztimeout)
if rc == -1 {
return 0, casterr(err)
}
for i, zi := range zitems {
items[i].REvents = PollEvents(zi.revents)
}
return int(rc), nil
}