/** * @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); }
/** * 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); }
/** * 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); }
/* * 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 < 0} or {@code length < 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); } }