org.zeromq.ZMQ Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jzmq Show documentation
Show all versions of jzmq Show documentation
The 0MQ lightweight messaging kernel is a library which extends
the standard socket interfaces with features traditionally
provided by specialised messaging middleware products. 0MQ sockets
provide an abstraction of asynchronous message queues, multiple
messaging patterns, message filtering (subscriptions), seamless
access to multiple transport protocols and more.
This package contains the Java Bindings for ZeroMQ.
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);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy