/** * 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(ByteBuffer 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 ByteBuffer put(ByteBuffer src) { if (src is HeapByteBuffer) { if (src == this) throw new ArgumentException(); var sb = (HeapByteBuffer) 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 ArgumentException * If the source buffer is this buffer * * @throws ReadOnlyBufferException * If this buffer is read-only */ public virtual ByteBuffer put(ByteBuffer src) { if (src == this) throw new ArgumentException(); int n = src.remaining(); if (n > remaining()) throw new BufferOverflowException(); for (int i = 0; i < n; i++) put(src.get()); return this; }