java.nio.channels.ScatteringByteChannel Java Examples

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ByteBuffer buf = ByteBuffer.wrap(array, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

private static int read(ReadableByteChannel src, ByteBuf dst) throws IOException {
    if (src instanceof ScatteringByteChannel) {
        return dst.writeBytes((ScatteringByteChannel) src, dst.writableBytes());
    }

    final int readBytes = src.read(dst.nioBuffer(dst.writerIndex(), dst.writableBytes()));
    if (readBytes > 0) {
        dst.writerIndex(dst.writerIndex() + readBytes);
    }
    return readBytes;
}
 

@Override
public final int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    checkIndex(index, length);
    index = idx(index);
    try {
        return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length));
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    try {
        return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length));
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ByteBuffer tmpBuf = internalNioBuffer();
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpNioBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    checkIndex(index, length);
    ByteBuffer tmpBuf = internalNioBuffer();
    index = idx(index);
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
	// adapted from UnpooledDirectByteBuf:
	checkIndex(index, length);

	ByteBuffer tmpBuf = memorySegment.wrap(index, length);
	try {
		return in.read(tmpBuf);
	} catch (ClosedChannelException ignored) {
		return -1;
	}
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
	// adapted from UnpooledDirectByteBuf:
	checkIndex(index, length);

	ByteBuffer tmpBuf = memorySegment.wrap(index, length);
	try {
		return in.read(tmpBuf);
	} catch (ClosedChannelException ignored) {
		return -1;
	}
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    checkIndex(index, length);
    ByteBuffer tmpBuf = internalNioBuffer();
    index = idx(index);
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
protected int read(ByteChannel src, ByteBuf dst) throws IOException {
    if (src instanceof ScatteringByteChannel) {
        return dst.writeBytes((ScatteringByteChannel) src, dst.writableBytes());
    }

    final int readBytes = src.read(dst.nioBuffer(dst.writerIndex(), dst.writableBytes()));
    if (readBytes > 0) {
        dst.writerIndex(dst.writerIndex() + readBytes);
    }
    return readBytes;
}
 

@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
    ensureWritable(length);
    int writtenBytes = setBytes(writerIndex, in, length);
    if (writtenBytes > 0) {
        writerIndex += writtenBytes;
    }
    return writtenBytes;
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ByteBuffer tmpBuf = internalNioBuffer();
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    checkIndex(index, length);
    ByteBuffer tmpBuf = internalNioBuffer();
    index = idx(index);
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    try {
        return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length));
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    checkIndex(index, length);
    index = idx(index);
    try {
        return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length));
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ByteBuffer tmpBuf = internalNioBuffer();
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpNioBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public final long read(ScatteringByteChannel channel) throws IOException
{
    ByteBuffer[] byteBuffers = new ByteBuffer[_fragments.length];
    for (int i = 0; i < byteBuffers.length; i++)
    {
        final SingleQpidByteBuffer fragment = _fragments[i];
        byteBuffers[i] = fragment.getUnderlyingBuffer();
    }
    return channel.read(byteBuffers);
}
 

/**
 * Overwrites the current model parameter values with the values read from a channel.
 *
 * The channel should contain values previously written by
 * {@link #saveParameters(GatheringByteChannel)} for the same underlying model.
 *
 * @param inputChannel where to read the parameters from.
 * @throws IOException if an I/O error occurs.
 */
public void loadParameters(ScatteringByteChannel inputChannel) throws IOException {
  parameterLock.writeLock().lock();
  try {
    inputChannel.read(modelParameters);
    for (ByteBuffer buffer : modelParameters) {
      buffer.rewind();
    }
  } finally {
    parameterLock.writeLock().unlock();
  }
}
 

@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
    int writtenBytes = slice.setBytes(size, in, length);
    if (writtenBytes > 0) {
        size += writtenBytes;
    }
    return writtenBytes;
}
 

/**
 * Transfers the content of the specified source channel to this buffer starting at the
 * specified absolute {@code index}.
 *
 * @param length the maximum number of bytes to transfer
 * @return the actual number of bytes read in from the specified channel. {@code -1} if the
 *     specified channel is closed.
 * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or if
 *     {@code index + length} is greater than {@code this.capacity}
 * @throws java.io.IOException if the specified channel threw an exception during I/O
 */
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    Preconditions.checkPositionIndexes(index, index + length, this.length);
    index += offset;
    ByteBuffer buf = ByteBuffer.wrap(data, index, length);
    int readBytes = 0;

    do {
        int localReadBytes;
        try {
            localReadBytes = in.read(buf);
        } catch (ClosedChannelException e) {
            localReadBytes = -1;
        }
        if (localReadBytes < 0) {
            if (readBytes == 0) {
                return -1;
            } else {
                break;
            }
        } else if (localReadBytes == 0) {
            break;
        }
        readBytes += localReadBytes;
    } while (readBytes < length);

    return readBytes;
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
    ensureAccessible();
    ByteBuffer tmpBuf = internalNioBuffer();
    tmpBuf.clear().position(index).limit(index + length);
    try {
        return in.read(tmpBuf);
    } catch (ClosedChannelException ignored) {
        return -1;
    }
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
  throw new UnsupportedOperationException(ERROR_MESSAGE);
}
 

@Override
public int setBytes(int index, ScatteringByteChannel in, int length) {
    checkIndex(index, length);
    return 0;
}
 

@Override
public final long read(ScatteringByteChannel channel) throws IOException
{
    return channel.read(getUnderlyingBuffer());
}
 

@Override
public int writeBytes(ScatteringByteChannel in, int length) {
    checkLength(length);
    return 0;
}