Beispiel #1
0
        /**
         * @see
         * org.apache.commons.compress.archivers.zip.ZipEncoding#encode(java.lang.String)
         */
        public java.nio.ByteBuffer encode(String name)
        {
            java.nio.charset.CharsetEncoder enc = this.charset.newEncoder();

            enc.onMalformedInput(java.nio.charset.CodingErrorAction.REPORT);
            enc.onUnmappableCharacter(java.nio.charset.CodingErrorAction.REPORT);

            java.nio.CharBuffer cb   = java.nio.CharBuffer.wrap(name);
            java.nio.ByteBuffer outJ = java.nio.ByteBuffer.allocate(name.length()
                                                                    + (name.length() + 1) / 2);

            while (cb.remaining() > 0)
            {
                java.nio.charset.CoderResult res = enc.encode(cb, outJ, true);

                if (res.isUnmappable() || res.isMalformed())
                {
                    // write the unmappable characters in utf-16
                    // pseudo-URL encoding style to ByteBuffer.
                    if (res.length() * 6 > outJ.remaining())
                    {
                        outJ = ZipEncodingHelper.growBuffer(outJ, outJ.position()
                                                            + res.length() * 6);
                    }

                    for (int i = 0; i < res.length(); ++i)
                    {
                        ZipEncodingHelper.appendSurrogate(outJ, cb.get());
                    }
                }
                else if (res.isOverflow())
                {
                    outJ = ZipEncodingHelper.growBuffer(outJ, 0);
                }
                else if (res.isUnderflow())
                {
                    enc.flush(outJ);
                    break;
                }
            }

            outJ.limit(outJ.position());
            outJ.rewind();
            return(outJ);
        }
Beispiel #2
0
        /**
         * Grow a byte buffer, so it has a minimal capacity or at least
         * the double capacity of the original buffer
         *
         * @param b The original buffer.
         * @param newCapacity The minimal requested new capacity.
         * @return A byte buffer <code>r</code> with
         *         <code>r.capacity() = max(b.capacity()*2,newCapacity)</code> and
         *         all the data contained in <code>b</code> copied to the beginning
         *         of <code>r</code>.
         *
         */
        internal static java.nio.ByteBuffer growBuffer(java.nio.ByteBuffer b, int newCapacity)
        {
            b.limit(b.position());
            b.rewind();

            int c2 = b.capacity() * 2;

            java.nio.ByteBuffer on = java.nio.ByteBuffer.allocate(c2 < newCapacity ? newCapacity : c2);

            on.put(b);
            return(on);
        }
Beispiel #3
0
 /**
  * Updates this {@code MessageDigestSpi} using the given {@code input}.
  *
  * @param input
  *            the {@code ByteBuffer}.
  */
 protected internal virtual void engineUpdate(java.nio.ByteBuffer input)
 {
     if (!input.hasRemaining())
     {
         return;
     }
     byte[] tmp;
     if (input.hasArray())
     {
         tmp = (byte[])input.array();
         int offset   = input.arrayOffset();
         int position = input.position();
         int limit    = input.limit();
         engineUpdate(tmp, offset + position, limit - position);
         input.position(limit);
     }
     else
     {
         tmp = new byte[input.limit() - input.position()];
         input.get(tmp);
         engineUpdate(tmp, 0, tmp.Length);
     }
 }
        /**
         * @see
         * org.apache.commons.compress.archivers.zip.ZipEncoding#encode(java.lang.String)
         */
        public java.nio.ByteBuffer encode(String name)
        {
            java.nio.ByteBuffer outJ = java.nio.ByteBuffer.allocate(name.length()
                                                                    + 6 + (name.length() + 1) / 2);

            for (int i = 0; i < name.length(); ++i)
            {
                char c = name.charAt(i);

                if (outJ.remaining() < 6)
                {
                    outJ = ZipEncodingHelper.growBuffer(outJ, outJ.position() + 6);
                }

                if (!this.pushEncodedChar(outJ, c))
                {
                    ZipEncodingHelper.appendSurrogate(outJ, c);
                }
            }

            outJ.limit(outJ.position());
            outJ.rewind();
            return(outJ);
        }
Beispiel #5
0
        /*
         * Reads at most {@code length} characters from this reader and stores them
         * at position {@code offset} in the character array {@code buf}. Returns
         * the number of characters actually read or -1 if the end of the reader has
         * been reached. The bytes are either obtained from converting bytes in this
         * reader's buffer or by first filling the buffer from the source
         * InputStream and then reading from the buffer.
         *
         * @param buf
         *            the array to store the characters read.
         * @param offset
         *            the initial position in {@code buf} to store the characters
         *            read from this reader.
         * @param length
         *            the maximum number of characters to read.
         * @return the number of characters read or -1 if the end of the reader has
         *         been reached.
         * @throws IndexOutOfBoundsException
         *             if {@code offset &lt; 0} or {@code length &lt; 0}, or if
         *             {@code offset + length} is greater than the length of
         *             {@code buf}.
         * @throws IOException
         *             if this reader is closed or some other I/O error occurs.
         */
        public override int read(char[] buf, int offset, int length)
        {// throws IOException {
            lock (lockJ)
            {
                if (!isOpen())
                {
                    // luni.BA=InputStreamReader is closed.
                    throw new IOException("InputStreamReader is closed."); //$NON-NLS-1$
                }
                if (offset < 0 || offset > buf.Length - length || length < 0)
                {
                    throw new java.lang.IndexOutOfBoundsException();
                }
                if (length == 0)
                {
                    return(0);
                }

                java.nio.CharBuffer          outJ   = java.nio.CharBuffer.wrap(buf, offset, length);
                java.nio.charset.CoderResult result = java.nio.charset.CoderResult.UNDERFLOW;

                // bytes.remaining() indicates number of bytes in buffer
                // when 1-st time entered, it'll be equal to zero
                bool needInput = !bytes.hasRemaining();

                while (outJ.hasRemaining())
                {
                    // fill the buffer if needed
                    if (needInput)
                    {
                        try
                        {
                            if ((inJ.available() == 0) &&
                                (outJ.position() > offset))
                            {
                                // we could return the result without blocking read
                                break;
                            }
                        }
                        catch (IOException e)
                        {
                            // available didn't work so just try the read
                        }

                        int to_read = bytes.capacity() - bytes.limit();
                        int off     = bytes.arrayOffset() + bytes.limit();
                        int was_red = inJ.read((byte[])bytes.array(), off, to_read);

                        if (was_red == -1)
                        {
                            endOfInput = true;
                            break;
                        }
                        else if (was_red == 0)
                        {
                            break;
                        }
                        bytes.limit(bytes.limit() + was_red);
                        needInput = false;
                    }

                    // decode bytes
                    result = decoder.decode(bytes, outJ, false);

                    if (result.isUnderflow())
                    {
                        // compact the buffer if no space left
                        if (bytes.limit() == bytes.capacity())
                        {
                            bytes.compact();
                            bytes.limit(bytes.position());
                            bytes.position(0);
                        }
                        needInput = true;
                    }
                    else
                    {
                        break;
                    }
                }

                if (result == java.nio.charset.CoderResult.UNDERFLOW && endOfInput)
                {
                    result = decoder.decode(bytes, outJ, true);
                    decoder.flush(outJ);
                    decoder.reset();
                }
                if (result.isMalformed())
                {
                    throw new java.nio.charset.MalformedInputException(result.length());
                }
                else if (result.isUnmappable())
                {
                    throw new java.nio.charset.UnmappableCharacterException(result.length());
                }

                return(outJ.position() - offset == 0 ? -1 : outJ.position() - offset);
            }
        }