Java ByteBuffer Write write(WritableByteChannel channel, ByteBuffer[] srcs, int offset, int length)

Description

GatheringChannel support.

License

Open Source License

Parameter

Parameter	Description
channel	a parameter
srcs	a parameter
offset	a parameter
length	a parameter

Exception

Parameter	Description
IOException	an exception

Declaration

public static final long write(WritableByteChannel channel, ByteBuffer[] srcs, int offset, int length)
        throws IOException 

Method Source Code

//package com.java2s;
/*/*from   w  w  w .  java 2  s  .  c o m*/
 * Copyright (C) 2015 Timo Vesalainen <timo.vesalainen@iki.fi>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.GatheringByteChannel;

import java.nio.channels.WritableByteChannel;
import java.nio.charset.Charset;

public class Main {
    /**
     * Writes string bytes to channel using charset.
     * @param ch
     * @param text
     * @param charset
     * @throws IOException 
     */
    public static final void write(WritableByteChannel ch, String text, Charset charset) throws IOException {
        write(ch, text.getBytes(charset));
    }

    /**
     * Writes bytes to channel
     * @param ch
     * @param bytes
     * @throws IOException 
     */
    public static final void write(WritableByteChannel ch, byte[] bytes) throws IOException {
        write(ch, bytes, 0, bytes.length);
    }

    /**
     * Writes length bytes to channel starting at offset
     * @param ch
     * @param bytes
     * @param offset
     * @param length
     * @throws IOException 
     */
    public static final void write(WritableByteChannel ch, byte[] bytes, int offset, int length)
            throws IOException {
        ByteBuffer bb = ByteBuffer.allocate(length);
        bb.put(bytes, offset, length);
        bb.flip();
        writeAll(ch, bb);
    }

    /**
     * GatheringChannel support.
     * @param channel
     * @param srcs
     * @param offset
     * @param length
     * @return
     * @throws IOException 
     */
    public static final long write(WritableByteChannel channel, ByteBuffer[] srcs, int offset, int length)
            throws IOException {
        long res = 0;
        for (int ii = 0; ii < length; ii++) {
            ByteBuffer bb = srcs[ii + offset];
            if (bb.hasRemaining()) {
                res += channel.write(bb);
                if (bb.hasRemaining()) {
                    break;
                }
            }
        }
        return res;
    }

    /**
     * GatheringChannel support.
     * @param channel
     * @param srcs
     * @return
     * @throws IOException 
     */
    public static final long write(WritableByteChannel channel, ByteBuffer[] srcs) throws IOException {
        return write(channel, srcs, 0, srcs.length);
    }

    public static void writeAll(GatheringByteChannel ch, ByteBuffer... bbs) throws IOException {
        writeAll(ch, bbs, 0, bbs.length);
    }

    /**
     * Attempts to write all remaining data in bbs.
     * @param ch Target
     * @param bbs 
     * @param offset
     * @param length
     * @throws IOException If couldn't write all.
     */
    public static void writeAll(GatheringByteChannel ch, ByteBuffer[] bbs, int offset, int length)
            throws IOException {
        long all = 0;
        for (int ii = 0; ii < length; ii++) {
            all += bbs[offset + ii].remaining();
        }
        int count = 0;
        while (all > 0) {
            long rc = ch.write(bbs, offset, length);
            if (rc == 0) {
                count++;
            } else {
                all -= rc;
            }
            if (count > 100) {
                throw new IOException("Couldn't write all.");
            }
        }
    }

    /**
     * Writes to ch until no remaining left or throws IOException
     * @param ch
     * @param bb
     * @throws IOException 
     */
    public static void writeAll(WritableByteChannel ch, ByteBuffer bb) throws IOException {
        int count = 0;
        while (bb.hasRemaining()) {
            int rc = ch.write(bb);
            if (rc == 0) {
                count++;
            }
            if (count > 100) {
                throw new IOException("Couldn't write all.");
            }
        }
    }
}

Related

1. write(MappedByteBuffer buffer, int pos, String asciString)
2. write(SocketChannel channel, ByteBuffer b, PrimitiveIterator.OfInt iterator)
3. write(SocketChannel p_channel, SSLEngine p_sslEngine, ByteBuffer p_outAppBuf, ByteBuffer p_outNetBuf)
4. write(WritableByteChannel channel, ByteBuffer buffer, byte[] data)
5. write(WritableByteChannel channel, ByteBuffer[] srcs)
6. write(WritableByteChannel out, ByteBuffer buffer)
7. write(WritableByteChannel socketChannel, SSLEngine engine, ByteBuffer plainOut, ByteBuffer cypherOut)
8. writeAll(ByteBuffer buf, WritableByteChannel channel)
9. writeAll(ByteChannel channel, ByteBuffer buffer)