EpollIoOps Class — netty Architecture

Source Code

transport-classes-epoll/src/main/java/io/netty/channel/epoll/EpollIoOps.java lines 23–209

public final class EpollIoOps implements IoOps {

    static {
        // Need to ensure we load the native lib before trying to use the values in Native to construct the different
        // instances.
        Epoll.ensureAvailability();
    }

    /**
     * Interested in IO events which tell that the underlying channel is writable again or a connection
     * attempt can be continued.
     */
    public static final EpollIoOps EPOLLOUT = new EpollIoOps(Native.EPOLLOUT);

    /**
     * Interested in IO events which should be handled by finish pending connect operations
     */
    public static final EpollIoOps EPOLLIN = new EpollIoOps(Native.EPOLLIN);

    /**
     * Error condition happened on the associated file descriptor.
     */
    public static final EpollIoOps EPOLLERR = new EpollIoOps(Native.EPOLLERR);

    /**
     * Interested in IO events which should be handled by reading data.
     */
    public static final EpollIoOps EPOLLRDHUP = new EpollIoOps(Native.EPOLLRDHUP);

    public static final EpollIoOps EPOLLET = new EpollIoOps(Native.EPOLLET);

    static final int EPOLL_ERR_OUT_MASK = EpollIoOps.EPOLLERR.value | EpollIoOps.EPOLLOUT.value;
    static final int EPOLL_ERR_IN_MASK = EpollIoOps.EPOLLERR.value | EpollIoOps.EPOLLIN.value;
    static final int EPOLL_RDHUP_MASK = EpollIoOps.EPOLLRDHUP.value;

    // Just use an array to store often used values.
    private static final EpollIoEvent[] EVENTS;

    static {
        EpollIoOps all = new EpollIoOps(EPOLLOUT.value | EPOLLIN.value | EPOLLERR.value | EPOLLRDHUP.value);
        EVENTS = new EpollIoEvent[all.value + 1];
        addToArray(EVENTS, EPOLLOUT);
        addToArray(EVENTS, EPOLLIN);
        addToArray(EVENTS, EPOLLERR);
        addToArray(EVENTS, EPOLLRDHUP);
        addToArray(EVENTS, all);
    }

    private static void addToArray(EpollIoEvent[] array, EpollIoOps ops) {
        array[ops.value] = new DefaultEpollIoEvent(ops);
    }

    final int value;

    private EpollIoOps(int value) {
        this.value = value;
    }

    /**
     * Returns {@code true} if this {@link EpollIoOps} is a combination of the given {@link EpollIoOps}.
     * @param ops   the ops.
     * @return      {@code true} if a combination of the given.
     */
    public boolean contains(EpollIoOps ops) {
        return (value & ops.value) != 0;
    }

    boolean contains(int value) {
        return (this.value & value) != 0;
    }

    /**
     * Return a {@link EpollIoOps} which is a combination of the current and the given {@link EpollIoOps}.
     *
     * @param ops   the {@link EpollIoOps} that should be added to this one.
     * @return      a {@link EpollIoOps}.
     */
    public EpollIoOps with(EpollIoOps ops) {
        if (contains(ops)) {
            return this;
        }