C# ByteBuffer.position方法代码示例

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

 public void decompress(ByteBuffer @in, ByteBuffer @out)
 {
     if (@in.isDirect() && @out.isDirect())
     {
         directDecompress(@in, @out);
         return;
     }
     int inOffset = @in.position();
     int uncompressLen =
         Snappy.uncompress(@in.array(), @in.arrayOffset() + inOffset,
         @in.limit() - inOffset, @out.array(), @out.arrayOffset() + @out.position());
     @out.position(uncompressLen + @out.position());
     @out.flip();
 }

 public void decompress(ByteBuffer @in, ByteBuffer @out)
 {
     using (ByteBufferInputStream input = new ByteBufferInputStream(@in.duplicate()))
     using (DeflateStream inflater = new DeflateStream(input, CompressionMode.Decompress))
     using (ByteBufferOutputStream output = new ByteBufferOutputStream(@out))
     {
         inflater.CopyTo(output);
     }
     @out.flip();
     @in.position(@in.limit());
 }

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

		private void copyPlane(ByteBuffer src, ByteBuffer dst)
		{
			src.position(0).limit(src.capacity());
			dst.put(src);
			dst.position(0).limit(dst.capacity());
		}