C# ByteBuffer.remaining方法代码示例

 public bool compress(ByteBuffer @in, ByteBuffer @out, ByteBuffer overflow)
 {
     int inBytes = @in.remaining();
     // I should work on a patch for Snappy to support an overflow buffer
     // to prevent the extra buffer copy.
     byte[] compressed = new byte[Snappy.maxCompressedLength(inBytes)];
     int outBytes =
         Snappy.compress(@in.array(), @in.arrayOffset() + @in.position(), inBytes,
             compressed, 0);
     if (outBytes < inBytes)
     {
         int remaining = @out.remaining();
         if (remaining >= outBytes)
         {
             Array.Copy(compressed, 0, @out.array(), @out.arrayOffset() +
                 @out.position(), outBytes);
             @out.position(@out.position() + outBytes);
         }
         else
         {
             Array.Copy(compressed, 0, @out.array(), @out.arrayOffset() +
                 @out.position(), remaining);
             @out.position(@out.limit());
             Array.Copy(compressed, remaining, overflow.array(),
                 overflow.arrayOffset(), outBytes - remaining);
             overflow.position(outBytes - remaining);
         }
         return true;
     }
     else
     {
         return false;
     }
 }

		internal protected override CoderResult decodeLoop (ByteBuffer @in, CharBuffer @out)
		{
			int byte_count = @in.remaining ();
			int char_count = @out.capacity ();
			if (byte_count < 1)
				return CoderResult.UNDERFLOW;
			byte[] bytes = new byte [byte_count];
			@in.get (bytes, 0, byte_count);

			char[] chars = new char [char_count];
			int bytes_used, chars_used;
			bool completed;
			decoder.Convert (
				bytes, 0, byte_count, chars, 0, char_count, false,
				out bytes_used, out chars_used, out completed);

			if (bytes_used != byte_count)
				return CoderResult.OVERFLOW;

			@out.put (chars, 0, chars_used);
			return CoderResult.UNDERFLOW;
		}

 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;
 }

        /**
     * 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();
        }

        // -- Bulk put operations --

        /**
     * Relative bulk <i>put</i> method&nbsp;&nbsp;<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>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>,
     * then no bytes are transferred and a {@link
     * BufferOverflowException} is thrown.
     *
     * <p> Otherwise, this method copies
     * <i>n</i>&nbsp;=&nbsp;<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;
        }

 public void output(ByteBuffer buffer)
 {
     this.buffer.add(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());
 }

	public bool Equals(ByteBuffer other)
	{
		if (other != null && this.remaining() == other.remaining())
		{
			long thisOriginalPosition = this.position();
			long otherOriginalPosition = other.position();

			bool differenceFound = false;
			while (stream.Position < stream.Length)
			{
				if (this.get() != other.get())
				{
					differenceFound = true;
					break;
				}
			}

			this.position(thisOriginalPosition);
			other.position(otherOriginalPosition);

			return ! differenceFound;
		}
		else
			return false;
	}

        public CoderResult encode(
			CharBuffer inBuff, ByteBuffer outBuff, bool endOfInput )
        {
            int oldPosition;
            byte[] ba = new byte[32];
            char[] ca = new char[1];

            while(inBuff.hasRemaining())
            {
                oldPosition = inBuff.position();  // save the input position
                ca[1] = inBuff.get();             // get the next character
                int count = encoding.GetBytes(ca, 0, 1, ba, 0);
                if (count > outBuff.remaining())
                {
                    inBuff.position(oldPosition);
                    return CoderResult.OVERFLOW;
                }
                outBuff.put(ba, 0, count);  // move the bytes into ByteBuffer
            }
            return CoderResult.UNDERFLOW;
        }