org.xnio.channels.AssembledMessageChannel Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of wildfly-client-all
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up with different versions on classes on the class path).
There is a newer version: 33.0.2.Final
Show newest version
/*
 * JBoss, Home of Professional Open Source.
 *
 * Copyright 2012 Red Hat, Inc. and/or its affiliates, and individual
 * contributors as indicated by the @author tags.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.xnio.channels;

import static org.xnio._private.Messages.msg;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.concurrent.TimeUnit;
import org.xnio.ChannelListener;
import org.xnio.ChannelListeners;
import org.xnio.Option;
import org.xnio.XnioExecutor;
import org.xnio.XnioIoThread;
import org.xnio.XnioWorker;

/**
 * A bidirectional message channel assembled from a readable and writable message channel.
 *
 * @author David M. Lloyd
 */
public class AssembledMessageChannel implements MessageChannel {
    private final CloseableChannel closeable;
    private final ReadableMessageChannel readable;
    private final WritableMessageChannel writable;

    private final ChannelListener.Setter readSetter;
    private final ChannelListener.Setter writeSetter;
    private final ChannelListener.Setter closeSetter;

    /**
     * Construct a new instance.
     *
     * @param closeable the single central closeable channel
     * @param readable the read channel
     * @param writable the write channel
     */
    public AssembledMessageChannel(final CloseableChannel closeable, final ReadableMessageChannel readable, final WritableMessageChannel writable) {
        if (readable.getWorker() != writable.getWorker() || readable.getWorker() != closeable.getWorker()) {
            throw msg.differentWorkers();
        }
        this.closeable = closeable;
        this.readable = readable;
        this.writable = writable;
        readSetter = ChannelListeners.getDelegatingSetter(readable.getReadSetter(), this);
        writeSetter = ChannelListeners.getDelegatingSetter(writable.getWriteSetter(), this);
        closeSetter = ChannelListeners.getDelegatingSetter(closeable.getCloseSetter(), this);
    }

    /**
     * Construct a new instance.
     *
     * @param readable the read channel
     * @param writable the write channel
     */
    public AssembledMessageChannel(final ReadableMessageChannel readable, final WritableMessageChannel writable) {
        this(new AssembledChannel(readable, writable), readable, writable);
    }

    public XnioIoThread getIoThread() {
        // both should be the same
        return readable.getIoThread();
    }

    // Read side

    public ChannelListener.Setter getReadSetter() {
        return readSetter;
    }

    public void suspendReads() {
        readable.suspendReads();
    }

    public void resumeReads() {
        readable.resumeReads();
    }

    public boolean isReadResumed() {
        return readable.isReadResumed();
    }

    public void wakeupReads() {
        readable.wakeupReads();
    }

    public void shutdownReads() throws IOException {
        readable.shutdownReads();
    }

    public void awaitReadable() throws IOException {
        readable.awaitReadable();
    }

    public void awaitReadable(final long time, final TimeUnit timeUnit) throws IOException {
        readable.awaitReadable(time, timeUnit);
    }

    @Deprecated
    public XnioExecutor getReadThread() {
        return readable.getReadThread();
    }

    public int receive(final ByteBuffer buffer) throws IOException {
        return readable.receive(buffer);
    }

    public long receive(final ByteBuffer[] buffers) throws IOException {
        return readable.receive(buffers);
    }

    public long receive(final ByteBuffer[] buffers, final int offs, final int len) throws IOException {
        return readable.receive(buffers, offs, len);
    }

    // Write side

    public ChannelListener.Setter getWriteSetter() {
        return writeSetter;
    }

    public void suspendWrites() {
        writable.suspendWrites();
    }

    public void resumeWrites() {
        writable.resumeWrites();
    }

    public boolean isWriteResumed() {
        return writable.isWriteResumed();
    }

    public void wakeupWrites() {
        writable.wakeupWrites();
    }

    public void shutdownWrites() throws IOException {
        writable.shutdownWrites();
    }

    public void awaitWritable() throws IOException {
        writable.awaitWritable();
    }

    public void awaitWritable(final long time, final TimeUnit timeUnit) throws IOException {
        writable.awaitWritable(time, timeUnit);
    }

    @Deprecated
    public XnioExecutor getWriteThread() {
        return writable.getWriteThread();
    }

    public boolean send(final ByteBuffer buffer) throws IOException {
        return writable.send(buffer);
    }

    public boolean send(final ByteBuffer[] buffers) throws IOException {
        return writable.send(buffers);
    }

    public boolean send(final ByteBuffer[] buffers, final int offs, final int len) throws IOException {
        return writable.send(buffers, offs, len);
    }

    @Override
    public boolean sendFinal(ByteBuffer buffer) throws IOException {
        return writable.sendFinal(buffer);
    }

    @Override
    public boolean sendFinal(ByteBuffer[] buffers) throws IOException {
        return writable.sendFinal(buffers);
    }

    @Override
    public boolean sendFinal(ByteBuffer[] buffers, int offs, int len) throws IOException {
        return writable.sendFinal(buffers, offs, len);
    }

    public boolean flush() throws IOException {
        return writable.flush();
    }

    // Single side

    public ChannelListener.Setter getCloseSetter() {
        return closeSetter;
    }

    public XnioWorker getWorker() {
        return closeable.getWorker();
    }

    public void close() throws IOException {
        closeable.close();
    }

    public boolean isOpen() {
        return closeable.isOpen();
    }

    public boolean supportsOption(final Option option) {
        return closeable.supportsOption(option);
    }

    public  T getOption(final Option option) throws IOException {
        return closeable.getOption(option);
    }

    public  T setOption(final Option option, final T value) throws IllegalArgumentException, IOException {
        return closeable.setOption(option, value);
    }
}