com.barchart.udt.nio.AdapterInputStreamUDT Maven / Gradle / Ivy

Go to download
/**
 * Copyright (C) 2009-2012 Barchart, Inc. 
 *
 * All rights reserved. Licensed under the OSI BSD License.
 *
 * http://www.opensource.org/licenses/bsd-license.php
 */
package com.barchart.udt.nio;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.IllegalBlockingModeException;
import java.nio.channels.SocketChannel;

/**
 * {@link InputStream} implementation for UDT sockets.
 */
class AdapterInputStreamUDT extends InputStream {

	private final SocketChannel channel;

	/**
	 * Creates a new input stream for the specified channel.
	 * 
	 * @param channel
	 *            The UDT socket channel.
	 * @param socketUDT
	 *            The UDT socket.
	 */
	AdapterInputStreamUDT(final SocketChannel channel, final Socket socketUDT) {
		if (channel == null) {
			throw new NullPointerException("Null SocketChannel");
		}
		if (!channel.isBlocking()) {
			throw new IllegalBlockingModeException();
		}
		this.channel = channel;
	}

	@Override
	public int read() throws IOException {

		/*
		 * Here's the contract from the JavaDoc on this for SocketChannel:
		 * 
		 * A read operation might not fill the buffer, and in fact it might not
		 * read any bytes at all. Whether or not it does so depends upon the
		 * nature and state of the channel. A socket channel in non-blocking
		 * mode, for example, cannot read any more bytes than are immediately
		 * available from the socket's input buffer; similarly, a file channel
		 * cannot read any more bytes than remain in the file. It is guaranteed,
		 * however, that if a channel is in blocking mode and there is at least
		 * one byte remaining in the buffer then this method will block until at
		 * least one byte is read.
		 * 
		 * Long story short: This UDT InputStream should only ever be created
		 * when the SocketChannel's in blocking mode, and when it's in blocking
		 * mode the SocketChannel read call below will block just like we need
		 * it too.
		 */

		final byte[] data = new byte[1];
		read(data);
		return data[0];
	}

	@Override
	public int read(final byte[] bytes) throws IOException {
		return read(bytes, 0, bytes.length);
	}

	@Override
	public int read(final byte[] bytes, final int off, final int len)
			throws IOException {

		final ByteBuffer bb = ByteBuffer.wrap(bytes);
		bb.position(off);

		final int read = channel.read(bb);
		return read;
	}

	@Override
	public long skip(final long n) throws IOException {
		throw new UnsupportedOperationException("skip not supported");
	}

	@Override
	public int available() throws IOException {
		// This is the default InputStream return value.
		// The java/net/SocketInputStream.java implementation delegates to
		// the native implementation, which returns 0 on at least some OSes.
		return 0;
	}

	@Override
	public void close() throws IOException {
		channel.close();
	}

	@Override
	public synchronized void mark(final int readlimit) {
		throw new UnsupportedOperationException("mark not supported");
	}

	@Override
	public synchronized void reset() throws IOException {
		throw new UnsupportedOperationException("reset not supported");
	}

	@Override
	public boolean markSupported() {
		return false;
	}

}