private static void relGet(ByteBufferN b, int start)
{
int n = b.remaining();
for (int i = start; i < n; i++)
ck(b, b.get(), ((byte)ic(i)));
b.rewind();
}
private static void checkSlice(ByteBufferN b, ByteBufferN slice)
{
ck(slice, 0, slice.position());
ck(slice, b.remaining(), slice.limit());
ck(slice, b.remaining(), slice.capacity());
if (b.isDirect() != slice.isDirect())
fail("Lost direction", slice);
if (b.isReadOnly() != slice.isReadOnly())
fail("Lost read-only", slice);
}
/**
* Compares this buffer to another.
*
* <p> Two byte buffers are compared by comparing their sequences of
* remaining elements lexicographically, without regard to the starting
* position of each sequence within its corresponding buffer.
*
* <p> A byte buffer is not comparable to any other type of object.
*
* @return A negative integer, zero, or a positive integer as this buffer
* is less than, equal to, or greater than the given buffer
*/
public int compareTo(ByteBufferN that)
{
int n = position() + Math.Min(remaining(), that.remaining());
for (int i = position(), j = that.position(); i < n; i++, j++)
{
byte v1 = get(i);
byte v2 = that.get(j);
if (v1 == v2)
continue;
if (v1 < v2)
return -1;
return +1;
}
return remaining() - that.remaining();
}
public override ByteBufferN put(ByteBufferN src)
{
if (src is HeapByteBufferN)
{
if (src == this)
throw new IllegalArgumentException();
var sb = (HeapByteBufferN) src;
int n = sb.remaining();
if (n > remaining())
throw new BufferOverflowException();
Array.Copy(sb.hb, sb.ix(sb.position()),
hb, ix(position()), n);
sb.position(sb.position() + n);
position(position() + n);
}
else if (src.isDirect())
{
int n = src.remaining();
if (n > remaining())
throw new BufferOverflowException();
src.get(hb, ix(position()), n);
position(position() + n);
}
else
{
base.put(src);
}
return this;
}
// -- Bulk put operations --
/**
* Relative bulk <i>put</i> method <i>(optional operation)</i>.
*
* <p> This method transfers the bytes remaining in the given source
* buffer into this buffer. If there are more bytes remaining in the
* source buffer than in this buffer, that is, if
* <tt>src.remaining()</tt> <tt>></tt> <tt>remaining()</tt>,
* then no bytes are transferred and a {@link
* BufferOverflowException} is thrown.
*
* <p> Otherwise, this method copies
* <i>n</i> = <tt>src.remaining()</tt> bytes from the given
* buffer into this buffer, starting at each buffer's current position.
* The positions of both buffers are then incremented by <i>n</i>.
*
* <p> In other words, an invocation of this method of the form
* <tt>dst.put(src)</tt> has exactly the same effect as the loop
*
* <pre>
* while (src.hasRemaining())
* dst.put(src.get()); </pre>
*
* except that it first checks that there is sufficient space in this
* buffer and it is potentially much more efficient. </p>
*
* @param src
* The source buffer from which bytes are to be read;
* must not be this buffer
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
* for the remaining bytes in the source buffer
*
* @throws IllegalArgumentException
* If the source buffer is this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public virtual ByteBufferN put(ByteBufferN src)
{
if (src == this)
throw new IllegalArgumentException();
int n = src.remaining();
if (n > remaining())
throw new BufferOverflowException();
for (int i = 0; i < n; i++)
put(src.get());
return this;
}
