Mercurial > jhg
view src/org/tmatesoft/hg/internal/InflaterDataAccess.java @ 631:8a5cdcb27b8f
AIOOBE in HgManifest.RevisionMapper. Provide more details about exception context. Create lock file atomically. Test concurrent pull-rebase and read
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Thu, 30 May 2013 15:24:17 +0200 |
parents | ed243b668502 |
children | bcbcc318f250 |
line wrap: on
line source
/* * Copyright (c) 2011-2013 TMate Software Ltd * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; version 2 of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * For information on how to redistribute this software under * the terms of a license other than GNU General Public License * contact TMate Software at support@hg4j.com */ package org.tmatesoft.hg.internal; import java.io.EOFException; import java.io.IOException; import java.nio.ByteBuffer; import java.util.zip.DataFormatException; import java.util.zip.Inflater; import java.util.zip.ZipException; /** * DataAccess counterpart for InflaterInputStream. * XXX is it really needed to be subclass of FilterDataAccess? * * @author Artem Tikhomirov * @author TMate Software Ltd. */ public class InflaterDataAccess extends FilterDataAccess { private final Inflater inflater; private final byte[] inBuffer; private final ByteBuffer outBuffer; private int inflaterPos = 0; private int decompressedLength; public InflaterDataAccess(DataAccess dataAccess, long offset, int compressedLength) { this(dataAccess, offset, compressedLength, -1, new Inflater(), new byte[512]); } public InflaterDataAccess(DataAccess dataAccess, long offset, int compressedLength, int actualLength) { this(dataAccess, offset, compressedLength, actualLength, new Inflater(), new byte[512]); } public InflaterDataAccess(DataAccess dataAccess, long offset, int compressedLength, int actualLength, Inflater inflater, byte[] buf) { super(dataAccess, offset, compressedLength); if (inflater == null || buf == null) { throw new IllegalArgumentException(); } this.inflater = inflater; this.decompressedLength = actualLength; inBuffer = buf; outBuffer = ByteBuffer.allocate(inBuffer.length * 2); outBuffer.limit(0); // there's nothing to read in the buffer } @Override public InflaterDataAccess reset() throws IOException { super.reset(); inflater.reset(); inflaterPos = 0; outBuffer.clear().limit(0); // or flip(), to indicate nothing to read return this; } @Override protected int available() throws IOException { return length() - decompressedPosition(); } @Override public boolean isEmpty() throws IOException { // can't use super.available() <= 0 because even when 0 < super.count < 6(?) // decompressedPos might be already == length() return available() <= 0; } @Override public int length() throws IOException { if (decompressedLength != -1) { return decompressedLength; } decompressedLength = 0; // guard to avoid endless loop in case length() would get invoked from below. final int oldPos = decompressedPosition(); final int inflatedUpTo = inflaterPos; int inflatedMore = 0, c; do { outBuffer.limit(outBuffer.position()); // pretend the buffer is consumed c = fillOutBuffer(); inflatedMore += c; } while (c == outBuffer.capacity()); // once we unpacked less than capacity, input is over decompressedLength = inflatedUpTo + inflatedMore; reset(); seek(oldPos); return decompressedLength; } @Override public void seek(int localOffset) throws IOException { if (localOffset < 0 /* || localOffset >= length() */) { throw new IllegalArgumentException(); } int currentPos = decompressedPosition(); if (localOffset >= currentPos) { skip(localOffset - currentPos); } else { reset(); skip(localOffset); } } @Override public void skip(final int bytesToSkip) throws IOException { int bytes = bytesToSkip; if (bytes < 0) { bytes += decompressedPosition(); if (bytes < 0) { throw new IOException(String.format("Underflow. Rewind past start of the slice. To skip:%d, decPos:%d, decLen:%d. Left:%d", bytesToSkip, inflaterPos, decompressedLength, bytes)); } reset(); // fall-through } while (!isEmpty() && bytes > 0) { int fromBuffer = outBuffer.remaining(); if (fromBuffer > 0) { if (fromBuffer >= bytes) { outBuffer.position(outBuffer.position() + bytes); bytes = 0; break; } else { bytes -= fromBuffer; outBuffer.limit(outBuffer.position()); // mark consumed // fall through to fill the buffer } } fillOutBuffer(); } if (bytes != 0) { throw new IOException(String.format("Underflow. Rewind past end of the slice. To skip:%d, decPos:%d, decLen:%d. Left:%d", bytesToSkip, inflaterPos, decompressedLength, bytes)); } } @Override public byte readByte() throws IOException { if (!outBuffer.hasRemaining()) { fillOutBuffer(); } return outBuffer.get(); } @Override public void readBytes(byte[] b, int off, int len) throws IOException { int fromBuffer; do { fromBuffer = outBuffer.remaining(); if (fromBuffer > 0) { if (fromBuffer >= len) { outBuffer.get(b, off, len); return; } else { outBuffer.get(b, off, fromBuffer); off += fromBuffer; len -= fromBuffer; // fall-through } } fromBuffer = fillOutBuffer(); } while (len > 0 && fromBuffer > 0); if (len > 0) { // prevent hang up in this cycle if no more data is available, see Issue 25 throw new EOFException(String.format("No more compressed data is available to satisfy request for %d bytes. [finished:%b, needDict:%b, needInp:%b, available:%d", len, inflater.finished(), inflater.needsDictionary(), inflater.needsInput(), super.available())); } } @Override public void readBytes(ByteBuffer buf) throws IOException { int len = Math.min(available(), buf.remaining()); while (len > 0) { if (outBuffer.remaining() >= len) { ByteBuffer slice = outBuffer.slice(); slice.limit(len); buf.put(slice); outBuffer.position(outBuffer.position() + len); return; } else { len -= outBuffer.remaining(); buf.put(outBuffer); } fillOutBuffer(); } } private int decompressedPosition() { assert outBuffer.remaining() <= inflaterPos; return inflaterPos - outBuffer.remaining(); } // after #fillOutBuffer(), outBuffer is ready for read private int fillOutBuffer() throws IOException { assert !outBuffer.hasRemaining(); try { int inflatedBytes = 0; outBuffer.clear(); int len = outBuffer.capacity(); int off = 0; do { int n; while ((n = inflater.inflate(outBuffer.array(), off, len)) == 0) { // XXX few last bytes (checksum?) may be ignored by inflater, thus inflate may return 0 in // perfectly legal conditions (when all data already expanded, but there are still some bytes // in the input stream) int toRead = -1; if (inflater.needsInput() && (toRead = super.available()) > 0) { // fill if (toRead > inBuffer.length) { toRead = inBuffer.length; } super.readBytes(inBuffer, 0, toRead); inflater.setInput(inBuffer, 0, toRead); } else { // inflated nothing and doesn't want any more data (or no date available) - assume we're done assert inflater.finished(); assert toRead <= 0; break; } } off += n; len -= n; inflatedBytes += n; } while (len > 0 && !inflater.finished()); // either the buffer is filled or nothing more to unpack inflaterPos += inflatedBytes; outBuffer.limit(inflatedBytes); assert outBuffer.position() == 0; // didn't change since #clear() above return inflatedBytes; } catch (DataFormatException e) { String s = e.getMessage(); throw new ZipException(s != null ? s : "Invalid ZLIB data format"); } } }