public override java.nio.LongBuffer compact()
 {
     if (byteBuffer.isReadOnly())
     {
         throw new java.nio.ReadOnlyBufferException();
     }
     byteBuffer.limit(_limit * libcore.io.SizeOf.LONG);
     byteBuffer.position(_position * libcore.io.SizeOf.LONG);
     byteBuffer.compact();
     byteBuffer.clear();
     _position = _limit - _position;
     _limit    = _capacity;
     _mark     = UNSET_MARK;
     return(this);
 }
예제 #2
0
 /// <summary>
 /// Constructs a new InputStreamReader on the InputStream
 /// <code>in</code>
 /// and
 /// CharsetDecoder
 /// <code>dec</code>
 /// .
 /// </summary>
 /// <param name="in">the source InputStream from which to read characters.</param>
 /// <param name="dec">the CharsetDecoder used by the character conversion.</param>
 public InputStreamReader(java.io.InputStream @in, java.nio.charset.CharsetDecoder
                          dec) : base(@in)
 {
     dec.averageCharsPerByte();
     this.@in = @in;
     decoder  = dec;
     bytes.limit(0);
 }
예제 #3
0
 public java.nio.ByteBuffer AsByteBuffer()
 {
     java.nio.ByteBuffer dup = this.buffer.asReadOnlyBuffer();
     dup.position(this.offset);
     java.nio.ByteBuffer result = dup.slice();
     result.limit(this.size);
     return(result);
 }
예제 #4
0
        /// <exception cref="System.IO.IOException"/>
        public int Read(java.nio.ByteBuffer dst)
        {
            int size = System.Math.Min(dst.remaining(), this.buf.remaining());

            java.nio.ByteBuffer slice = this.buf.slice();
            slice.limit(size);
            dst.buffer = slice.buffer;
            dst.offset = slice.offset;
            dst.limit(size);
            dst.position(size);
            this.buf.position(this.buf.position() + size);
            return(size);
        }
예제 #5
0
 public java.nio.ByteBuffer[] getSegmentsForOutput()
 {
     java.nio.ByteBuffer[] result = new java.nio.ByteBuffer[this.segments.Count];
     for (int ii = 0; ii < this.segments.Count; ++ii)
     {
         Capnproto.SegmentBuilder segment = segments[ii];
         segment.buffer.rewind();
         java.nio.ByteBuffer slice = segment.buffer.slice();
         slice.limit(segment.currentSize() * Capnproto.Constants.BYTES_PER_WORD);
         slice.order(java.nio.ByteOrder.LITTLE_ENDIAN);
         result[ii] = slice;
     }
     return(result);
 }
예제 #6
0
        /// <summary>Pretty-print byte buffer in hex</summary>
        /// <param name="buffer"/>
        /// <returns/>
        public static string print(java.nio.ByteBuffer buffer)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            int lim = buffer.limit();

            for (int i = 0; i < lim; i++)
            {
                sb.Append(string.format("%x", buffer.get(i)));
                if (i % 8 == 7)
                {
                    sb.Append(" ");
                }
            }
            return(sb.ToString().Trim());
        }
예제 #7
0
        /// <summary>
        /// Copys the elements of a char buffer to a byte buffer
        /// Concurency: access must be externally synchronized
        /// </summary>
        /// <param name="src"/>
        /// <param name="dest"/>
        /// <returns>dest for easy invocation chaining</returns>
        public static java.nio.ByteBuffer copy(java.nio.CharBuffer src, java.nio.ByteBuffer
                                               dest)
        {
            int length = src.Length;
            int i;

            for (i = 0; i < length; i++)
            {
                dest.put(i, unchecked ((byte)src.get(i)));
            }
            for (; i < dest.limit(); i++)
            {
                dest.put(i, unchecked ((byte)0));
            }
            return(dest);
        }
예제 #8
0
        /// <exception cref="System.IO.IOException"/>
        public int Read(java.nio.ByteBuffer dst)
        {
            int numBytes = dst.remaining();

            if (numBytes < this.buf.remaining())
            {
                //# Serve from the current buffer.
                java.nio.ByteBuffer slice = this.buf.slice();
                slice.limit(numBytes);
                dst.put(slice);
                this.buf.position(this.buf.position() + numBytes);
                return(numBytes);
            }
            else
            {
                //# Copy current available into destination.
                int fromFirstBuffer = this.buf.remaining();
                {
                    java.nio.ByteBuffer slice = this.buf.slice();
                    slice.limit(fromFirstBuffer);
                    dst.put(slice);
                }
                numBytes -= fromFirstBuffer;
                if (numBytes <= this.buf.capacity())
                {
                    //# Read the next buffer-full.
                    this.buf.clear();
                    int n = readAtLeast(this.inner, this.buf, numBytes);
                    this.buf.rewind();
                    java.nio.ByteBuffer slice = this.buf.slice();
                    slice.limit(numBytes);
                    dst.put(slice);
                    this.buf.limit(n);
                    this.buf.position(numBytes);
                    return(fromFirstBuffer + numBytes);
                }
                else
                {
                    //# Forward large read to the underlying stream.
                    this.buf.clear();
                    this.buf.limit(0);
                    return(fromFirstBuffer + readAtLeast(this.inner, dst, numBytes));
                }
            }
        }
예제 #9
0
        /// <exception cref="System.IO.IOException"/>
        public int Write(java.nio.ByteBuffer src)
        {
            int available = this.buf.remaining();
            int size      = src.remaining();

            if (size <= available)
            {
                this.buf.put(src);
            }
            else if (size <= this.buf.capacity())
            {
                //# Too much for this buffer, but not a full buffer's worth,
                //# so we'll go ahead and copy.
                java.nio.ByteBuffer slice = src.slice();
                slice.limit(available);
                this.buf.put(slice);
                this.buf.rewind();
                while (this.buf.hasRemaining())
                {
                    this.inner.Write(this.buf);
                }
                this.buf.rewind();
                src.position(src.position() + available);
                this.buf.put(src);
            }
            else
            {
                //# Writing so much data that we might as well write
                //# directly to avoid a copy.
                int pos = this.buf.position();
                this.buf.rewind();
                java.nio.ByteBuffer slice = this.buf.slice();
                slice.limit(pos);
                while (slice.hasRemaining())
                {
                    this.inner.Write(slice);
                }
                while (src.hasRemaining())
                {
                    this.inner.Write(src);
                }
            }
            return(size);
        }
예제 #10
0
        public virtual java.nio.ByteBuffer put(java.nio.ByteBuffer src)
        {
            if (src == this)
            {
                throw new System.ArgumentException("src == this");
            }
            int srcByteCount = src.remaining();

            if (srcByteCount > remaining())
            {
                throw new java.nio.BufferOverflowException();
            }
            if (src.isDirect())
            {
                throw new System.InvalidOperationException();
            }
            byte[] srcObject = java.nio.NioUtils.unsafeArray(src);
            int    srcOffset = src.position();

            if (!src.isDirect())
            {
                srcOffset += java.nio.NioUtils.unsafeArrayOffset(src);
            }
            java.nio.ByteBuffer dst = this;
            if (dst.isDirect())
            {
                throw new System.InvalidOperationException();
            }
            byte[] dstObject = java.nio.NioUtils.unsafeArray(dst);
            int    dstOffset = dst.position();

            if (!dst.isDirect())
            {
                dstOffset += java.nio.NioUtils.unsafeArrayOffset(dst);
            }
            System.Array.Copy(srcObject, srcOffset, dstObject, dstOffset, srcByteCount);
            src.position(src.limit());
            dst.position(dst.position() + srcByteCount);
            return(this);
        }
예제 #11
0
        public static long computeSerializedSizeInWords(Capnproto.MessageBuilder message)
        {
            java.nio.ByteBuffer[] segments = message.GetSegmentsForOutput();
            //From the capnproto documentation:
            //"When transmitting over a stream, the following should be sent..."
            long bytes = 0;

            //"(4 bytes) The number of segments, minus one..."
            bytes += 4;
            //"(N * 4 bytes) The size of each segment, in words."
            bytes += segments.Length * 4;
            //"(0 or 4 bytes) Padding up to the next word boundary."
            if (bytes % 8 != 0)
            {
                bytes += 4;
            }
            //The content of each segment, in order.
            for (int i = 0; i < segments.Length; ++i)
            {
                java.nio.ByteBuffer s = segments[i];
                bytes += s.limit();
            }
            return(bytes / Capnproto.Constants.BYTES_PER_WORD);
        }
예제 #12
0
        public static void BlockCopy(ByteBuffer src, int srcPos, ByteBuffer dst, int dstPos, int length)
        {
            if (src.hasArray() && dst.hasArray())
            {
                java.lang.System.arraycopy(src.array(),
                                           src.arrayOffset() + srcPos,
                                           dst.array(),
                                           dst.arrayOffset() + dstPos,
                                           length);
            }
            else
            {
                if (src.limit() - srcPos < length || dst.limit() - dstPos < length)
                {
                    throw new java.lang.IndexOutOfBoundsException();
                }

                for (int i = 0; i < length; i++)
                {
                    // TODO: ByteBuffer.put is polymorphic, and might be slow here
                    dst.put(dstPos++, src.get(srcPos++));
                }
            }
        }
예제 #13
0
        /// <exception cref="System.IO.IOException"/>
        public int Read(java.nio.ByteBuffer outBuf)
        {
            if (outBuf.buffer == null)
            {
                outBuf.buffer = new byte[outBuf.remaining()];
            }
            int len = outBuf.remaining();

            if (len == 0)
            {
                return(0);
            }
            if (len % 8 != 0)
            {
                throw new System.Exception("PackedInputStream reads must be word-aligned");
            }
            int outPtr = outBuf.position();
            int outEnd = outPtr + len;

            java.nio.ByteBuffer inBuf = this.inner.GetReadBuffer();
            while (true)
            {
                byte tag = 0;
                if (inBuf.remaining() < 10)
                {
                    if (outBuf.remaining() == 0)
                    {
                        return(len);
                    }
                    if (inBuf.remaining() == 0)
                    {
                        inBuf = this.inner.GetReadBuffer();
                        continue;
                    }
                    //# We have at least 1, but not 10, bytes available. We need to read
                    //# slowly, doing a bounds check on each byte.
                    tag = inBuf.get();
                    for (int i = 0; i < 8; ++i)
                    {
                        if ((tag & (1 << i)) != 0)
                        {
                            if (inBuf.remaining() == 0)
                            {
                                inBuf = this.inner.GetReadBuffer();
                            }
                            outBuf.put(inBuf.get());
                        }
                        else
                        {
                            outBuf.put((byte)0);
                        }
                    }
                    if (inBuf.remaining() == 0 && (tag == 0 || tag == 0xff))
                    {
                        inBuf = this.inner.GetReadBuffer();
                    }
                }
                else
                {
                    tag = inBuf.get();
                    for (int n = 0; n < 8; ++n)
                    {
                        bool isNonzero = (tag & (1 << n)) != 0;
                        outBuf.put(unchecked ((byte)(inBuf.get() & (isNonzero? -1 : 0))));
                        inBuf.position(inBuf.position() + (isNonzero? 0 : -1));
                    }
                }
                if (tag == 0)
                {
                    if (inBuf.remaining() == 0)
                    {
                        throw new System.Exception("Should always have non-empty buffer here.");
                    }
                    int runLength = (unchecked ((int)(0xff)) & (int)inBuf.get()) * 8;
                    if (runLength > outEnd - outPtr)
                    {
                        throw new System.Exception("Packed input did not end cleanly on a segment boundary");
                    }
                    for (int i = 0; i < runLength; ++i)
                    {
                        outBuf.put((byte)0);
                    }
                }
                else if (tag == 0xff)
                {
                    int runLength = (unchecked ((int)(0xff)) & (int)inBuf.get()) * 8;
                    if (inBuf.remaining() >= runLength)
                    {
                        //# Fast path.
                        java.nio.ByteBuffer slice = inBuf.slice();
                        slice.limit(runLength);
                        outBuf.put(slice);
                        inBuf.position(inBuf.position() + runLength);
                    }
                    else
                    {
                        //# Copy over the first buffer, then do one big read for the rest.
                        runLength -= inBuf.remaining();
                        outBuf.put(inBuf);
                        java.nio.ByteBuffer slice = outBuf.slice();
                        slice.limit(runLength);
                        this.inner.Read(slice);
                        outBuf.position(outBuf.position() + runLength);
                        if (outBuf.remaining() == 0)
                        {
                            return(len);
                        }
                        inBuf = this.inner.GetReadBuffer();
                        continue;
                    }
                }
                if (outBuf.remaining() == 0)
                {
                    return(len);
                }
            }
        }
예제 #14
0
        /// <exception cref="System.IO.IOException"/>
        public int Write(java.nio.ByteBuffer inBuf)
        {
            int length = inBuf.remaining();

            java.nio.ByteBuffer @out       = this.inner.GetWriteBuffer();
            java.nio.ByteBuffer slowBuffer = java.nio.ByteBuffer.allocate(20);
            int inPtr = inBuf.position();
            int inEnd = inPtr + length;

            while (inPtr < inEnd)
            {
                if (@out.remaining() < 10)
                {
                    //# Oops, we're out of space. We need at least 10
                    //# bytes for the fast path, since we don't
                    //# bounds-check on every byte.
                    if (@out == slowBuffer)
                    {
                        int oldLimit = @out.limit();
                        @out.limit(@out.position());
                        @out.rewind();
                        this.inner.Write(@out);
                        @out.limit(oldLimit);
                    }
                    @out = slowBuffer;
                    @out.rewind();
                }
                int tagPos = @out.position();
                @out.position(tagPos + 1);
                byte curByte;
                curByte = inBuf.get(inPtr);
                byte bit0 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit0 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit1 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit1 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit2 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit2 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit3 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit3 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit4 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit4 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit5 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit5 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit6 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit6 - 1);
                inPtr  += 1;
                curByte = inBuf.get(inPtr);
                byte bit7 = (curByte != 0)? unchecked ((byte)1) : unchecked ((byte)0);
                @out.put(curByte);
                @out.position(@out.position() + bit7 - 1);
                inPtr += 1;
                byte tag = unchecked ((byte)((bit0 << 0) | (bit1 << 1) | (bit2 << 2) | (bit3 << 3)
                                             | (bit4 << 4) | (bit5 << 5) | (bit6 << 6) | (bit7 << 7)));
                @out.put(tagPos, tag);
                if (tag == 0)
                {
                    //# An all-zero word is followed by a count of
                    //# consecutive zero words (not including the first
                    //# one).
                    int runStart = inPtr;
                    int limit    = inEnd;
                    if (limit - inPtr > 255 * 8)
                    {
                        limit = inPtr + 255 * 8;
                    }
                    while (inPtr < limit && inBuf.getLong(inPtr) == 0)
                    {
                        inPtr += 8;
                    }
                    @out.put(unchecked ((byte)((inPtr - runStart) / 8)));
                }
                else if (tag == unchecked ((byte)unchecked ((int)(0xff))))
                {
                    //# An all-nonzero word is followed by a count of
                    //# consecutive uncompressed words, followed by the
                    //# uncompressed words themselves.
                    //# Count the number of consecutive words in the input
                    //# which have no more than a single zero-byte. We look
                    //# for at least two zeros because that's the point
                    //# where our compression scheme becomes a net win.
                    int runStart = inPtr;
                    int limit    = inEnd;
                    if (limit - inPtr > 255 * 8)
                    {
                        limit = inPtr + 255 * 8;
                    }
                    while (inPtr < limit)
                    {
                        byte c = 0;
                        for (int ii = 0; ii < 8; ++ii)
                        {
                            c     += (inBuf.get(inPtr) == 0 ? (byte)1 : (byte)0);
                            inPtr += 1;
                        }
                        if (c >= 2)
                        {
                            //# Un-read the word with multiple zeros, since
                            //# we'll want to compress that one.
                            inPtr -= 8;
                            break;
                        }
                    }
                    int count = inPtr - runStart;
                    @out.put(unchecked ((byte)(count / 8)));
                    if (count <= @out.remaining())
                    {
                        //# There's enough space to memcpy.
                        inBuf.position(runStart);
                        java.nio.ByteBuffer slice = inBuf.slice();
                        slice.limit(count);
                        @out.put(slice);
                    }
                    else
                    {
                        //# Input overruns the output buffer. We'll give it
                        //# to the output stream in one chunk and let it
                        //# decide what to do.
                        if (@out == slowBuffer)
                        {
                            int oldLimit = @out.limit();
                            @out.limit(@out.position());
                            @out.rewind();
                            this.inner.Write(@out);
                            @out.limit(oldLimit);
                        }
                        inBuf.position(runStart);
                        java.nio.ByteBuffer slice = inBuf.slice();
                        slice.limit(count);
                        while (slice.hasRemaining())
                        {
                            this.inner.Write(slice);
                        }
                        @out = this.inner.GetWriteBuffer();
                    }
                }
            }
            if (@out == slowBuffer)
            {
                @out.limit(@out.position());
                @out.rewind();
                this.inner.Write(@out);
            }
            inBuf.position(inPtr);
            return(length);
        }