org.zeromq.ZMQ Maven / Gradle / Ivy
The newest version!
/*
Copyright (c) 2007-2010 iMatix Corporation
This file is part of 0MQ.
0MQ is free software; you can redistribute it and/or modify it under
the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
0MQ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
Lesser GNU General Public License for more details.
You should have received a copy of the Lesser GNU General Public License
along with this program. If not, see
* Since ZeroMQ 3.0, the timeout parameter is in milliseconds,
* but prior to this the unit was microseconds.
*
* @param tout the timeout, as per zmq_poll if -1, it will block
* indefinitely until an event happens; if 0, it will
* return immediately; otherwise, it will wait for at most
* that many milliseconds/microseconds (see above).
*
* @see 2.1 docs
* @see 3.0 docs
*
* @return how many objects where signalled by poll ()
*/
public int poll(long tout) {
if (tout < -1) {
return 0;
}
if (this.size <= 0 || this.next <= 0) {
return 0;
}
return run_poll(this.items, this.used, tout);
}
/**
* Check whether the specified element in the poll set was signalled for input.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollin(int index) {
return poll_mask(index, POLLIN);
}
/**
* Check whether the specified element in the poll set was signalled for output.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollout(int index) {
return poll_mask(index, POLLOUT);
}
/**
* Check whether the specified element in the poll set was signalled for error.
*
* @param index
*
* @return true if the element was signalled.
*/
public boolean pollerr(int index) {
return poll_mask(index, POLLERR);
}
/**
* Constructor
*
* @param size the number of Sockets this poller will contain.
*/
public Poller(int size) {
this(null, size);
}
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
*/
protected Poller(Context context) {
this(context, SIZE_DEFAULT);
}
/**
* Class constructor.
*
* @param context a 0MQ context previously created.
* @param size the number of Sockets this poller will contain.
*/
protected Poller(Context context, int size) {
this.context = context;
this.size = size;
this.next = 0;
this.items = new PollItem[this.size];
freeSlots = new LinkedList();
}
/**
* Issue a poll call on the specified 0MQ items.
*
* Since ZeroMQ 3.0, the timeout parameter is in milliseconds, but prior to this the unit was
* microseconds.
*
* @param items an array of PollItem to poll.
* @param timeout the maximum timeout in milliseconds/microseconds (see above).
* @return how many objects where signalled by poll.
* @see 2.1 docs
* @see 3.0 docs
*/
protected native static int run_poll(PollItem[] items, int count, long timeout);
/**
* Check whether a specific mask was signalled by latest poll call.
*
* @param index the index indicating the socket.
* @param mask a combination of POLLIN, POLLOUT and POLLERR.
* @return true if specific socket was signalled as specified.
*/
private boolean poll_mask(int index, int mask) {
if (mask <= 0 || index < 0 || index >= this.next || this.items[index] == null) {
return false;
}
return (this.items[index].revents & mask) > 0;
}
private Context context = null;
private long timeout = -2; // mark as uninitialized
private int size = 0;
private int next = 0;
private int used = 0;
private PollItem[] items = null;
// When socket is removed from polling, store free slots here
private LinkedList freeSlots = null;
private static final int SIZE_DEFAULT = 32;
private static final int SIZE_INCREMENT = 16;
}
/**
* Inner class: Event.
* Monitor socket event class
*/
public static class Event {
private static native void nativeInit();
static {
nativeInit();
}
private final int event;
private final Object value;
private final String address;
private Event(int event, int value, String address) {
this(event, Integer.valueOf(value), address != null ? address : "");
}
public Event(int event, Object value, String address) {
this.event = event;
this.value = value;
this.address = address;
}
public int getEvent() {
return event;
}
public Object getValue() {
return value;
}
/**
* Get the address.
* For libzmq versions 3.2.x the address will be an empty string.
* @return
*/
public String getAddress() {
return address;
}
private static native Event recv(long socket, int flags) throws ZMQException;
/**
* Receive an event from a monitor socket.
* For libzmq versions 3.2.x the address will be an empty string.
* @param socket the socket
* @param flags the flags to apply to the receive operation.
* @return the received event or null if no message was received.
* @throws ZMQException
*/
public static Event recv(Socket socket, int flags) throws ZMQException {
return Event.recv(socket.socketHandle, flags);
}
/**
* Receive an event from a monitor socket.
* Does a blocking recv.
* For libzmq versions 3.2.x the address will be an empty string.
* @param socket the socket
* @return the received event.
* @throws ZMQException
*/
public static Event recv(Socket socket) throws ZMQException {
return Event.recv(socket, 0);
}
}
}