Java 类java.io.PushbackInputStream 实例源码

/**
 * Checks the InputStream if it contains  GZIP compressed data
 *
 * @param inputStream InputStream to be checked
 * @return true or false if the stream contains GZIP compressed data
 * @throws java.io.IOException if read from inputStream fails
 */
public static boolean isInputStreamGZIPCompressed(final PushbackInputStream inputStream) throws IOException {
    if (inputStream == null)
        return false;

    byte[] signature = new byte[2];
    int count = 0;
    try {
        while (count < 2) {
            int readCount = inputStream.read(signature, count, 2 - count);
            if (readCount < 0) return false;
            count = count + readCount;
        }
    } finally {
        inputStream.unread(signature, 0, count);
    }
    int streamHeader = ((int) signature[0] & 0xff) | ((signature[1] << 8) & 0xff00);
    return GZIPInputStream.GZIP_MAGIC == streamHeader;
}

/** Tests whether InputStream contains serialized data
* @param pbStream is pushback input stream; tests 4 bytes and then returns them back
* @return true if the file has serialized form
*/
static private final boolean isSerialized(PushbackInputStream pbStream)
throws IOException {
    int[] serialPattern = { '\u00AC', '\u00ED', '\u0000', '\u0005' }; //NOI18N patern for serialized objects
    byte[] checkedArray = new byte[serialPattern.length];
    int unsignedConv = 0;

    pbStream.read(checkedArray, 0, checkedArray.length);
    pbStream.unread(checkedArray);

    for (int i = 0; i < checkedArray.length; i++) {
        unsignedConv = (checkedArray[i] < 0) ? (checkedArray[i] + 256) : checkedArray[i];

        if (serialPattern[i] != unsignedConv) {
            return false;
        }
    }

    return true;
}

/**
 * Checks the InputStream if it contains  GZIP compressed data
 *
 * @param inputStream InputStream to be checked
 * @return true or false if the stream contains GZIP compressed data
 * @throws java.io.IOException if read from inputStream fails
 */
public static boolean isInputStreamGZIPCompressed(final PushbackInputStream inputStream) throws IOException {
    if (inputStream == null)
        return false;

    byte[] signature = new byte[2];
    int count = 0;
    try {
        while (count < 2) {
            int readCount = inputStream.read(signature, count, 2 - count);
            if (readCount < 0) return false;
            count = count + readCount;
        }
    } finally {
        inputStream.unread(signature, 0, count);
    }
    int streamHeader = ((int) signature[0] & 0xff) | ((signature[1] << 8) & 0xff00);
    return GZIPInputStream.GZIP_MAGIC == streamHeader;
}

/**
 * @param in the stream to wrap
 * @throws IOException
 */
public DeobfuscatingInputStream(InputStream in) throws IOException {
  super(null);

  final byte[] header = new byte[ObfuscatingOutputStream.HEADER.length()];
  readFully(in, header, 0, header.length);
  if (new String(header, "UTF-8").equals(ObfuscatingOutputStream.HEADER)) {
    this.in = new DeobfuscatingInputStreamImpl(in);
  }
  else {
    final PushbackInputStream pin =
      new PushbackInputStream(in, header.length);
    pin.unread(header);
    this.in = pin;
  }
}

/**
 * Fills {@code buf} with data from the given input stream and
 * returns an input stream from which you can still read all data,
 * including the data in buf.
 *
 * @param  in The stream to read from.
 * @param  buf The buffer to fill entirely with data.
 * @return A stream which holds all the data {@code in} did.
 * @throws EOFException on unexpected end-of-file.
 * @throws IOException on any I/O error.
 */
private static InputStream readAhead(
        final @WillNotClose InputStream in,
        final byte[] buf)
throws EOFException, IOException {
    if (in.markSupported()) {
        in.mark(buf.length);
        new DataInputStream(in).readFully(buf);
        in.reset();
        return in;
    } else {
        final PushbackInputStream
                pin = new PushbackInputStream(in, buf.length);
        new DataInputStream(pin).readFully(buf);
        pin.unread(buf);
        return pin;
    }
}

/**
 * In uuencoded buffers, encoded lines start with a character that
 * represents the number of bytes encoded in this line. The last
 * line of input is always a line that starts with a single space
 * character, which would be a zero length line.
 */
protected int decodeLinePrefix(PushbackInputStream inStream, OutputStream outStream) throws IOException {
    int     c;

    c = inStream.read();
    if (c == ' ') {
        c = inStream.read(); /* discard the (first)trailing CR or LF  */
        c = inStream.read(); /* check for a second one  */
        if ((c != '\n') && (c != -1))
            inStream.unread (c);
        throw new CEStreamExhausted();
    } else if (c == -1) {
        throw new CEFormatException("UUDecoder: Short Buffer.");
    }

    c = (c - ' ') & 0x3f;
    if (c > bytesPerLine()) {
        throw new CEFormatException("UUDecoder: Bad Line Length.");
    }
    return (c);
}

/**
 * Find the end of the line for the next operation.
 * The following sequences are recognized as end-of-line
 * CR, CR LF, or LF
 */
protected void decodeLineSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException {
    int c;
    while (true) {
        c = inStream.read();
        if (c == -1) {
            throw new CEStreamExhausted();
        }
        if (c == '\n') {
            break;
        }
        if (c == '\r') {
            c = inStream.read();
            if ((c != '\n') && (c != -1)) {
                inStream.unread (c);
            }
            break;
        }
    }
}

/**
 * Grants access to everyone.Removes authentication related bytes from the
 * stream, when a SOCKS5 connection is being made, selects an authentication
 * NONE.
 */
public ServerAuthenticator startSession(Socket s) throws IOException {

    final PushbackInputStream in = new PushbackInputStream(s
            .getInputStream());
    final OutputStream out = s.getOutputStream();

    final int version = in.read();
    if (version == 5) {
        if (!selectSocks5Authentication(in, out, 0)) {
            return null;
        }
    } else if (version == 4) {
        // Else it is the request message already, version 4
        in.unread(version);
    } else {
        return null;
    }

    return new ServerAuthenticatorNone(in, out);
}

/**
 * Decode a UU atom. Note that if l is less than 3 we don't write
 * the extra bits, however the encoder always encodes 4 character
 * groups even when they are not needed.
 */
protected void decodeAtom(PushbackInputStream inStream, OutputStream outStream, int l)
    throws IOException {
    int i, c1, c2, c3, c4;
    int a, b, c;
    StringBuffer x = new StringBuffer();

    for (i = 0; i < 4; i++) {
        c1 = inStream.read();
        if (c1 == -1) {
            throw new CEStreamExhausted();
        }
        x.append((char)c1);
        decoderBuffer[i] = (byte) ((c1 - ' ') & 0x3f);
    }
    a = ((decoderBuffer[0] << 2) & 0xfc) | ((decoderBuffer[1] >>> 4) & 3);
    b = ((decoderBuffer[1] << 4) & 0xf0) | ((decoderBuffer[2] >>> 2) & 0xf);
    c = ((decoderBuffer[2] << 6) & 0xc0) | (decoderBuffer[3] & 0x3f);
    outStream.write((byte)(a & 0xff));
    if (l > 1) {
        outStream.write((byte)( b & 0xff));
    }
    if (l > 2) {
        outStream.write((byte)(c&0xff));
    }
}

/**
 * Find the end of the line for the next operation.
 * The following sequences are recognized as end-of-line
 * CR, CR LF, or LF
 */
protected void decodeLineSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException {
    int c;
    while (true) {
        c = inStream.read();
        if (c == -1) {
            throw new CEStreamExhausted();
        }
        if (c == '\n') {
            break;
        }
        if (c == '\r') {
            c = inStream.read();
            if ((c != '\n') && (c != -1)) {
                inStream.unread (c);
            }
            break;
        }
    }
}

public static boolean isInputStreamGZIPCompressed(PushbackInputStream inputStream) throws
        IOException {
    boolean z = true;
    if (inputStream == null) {
        return false;
    }
    byte[] signature = new byte[2];
    int readStatus = inputStream.read(signature);
    inputStream.unread(signature);
    int streamHeader = (signature[0] & 255) | ((signature[1] << 8) & MotionEventCompat
            .ACTION_POINTER_INDEX_MASK);
    if (!(readStatus == 2 && 35615 == streamHeader)) {
        z = false;
    }
    return z;
}

@Override
public InputStream getContent() throws IOException {
    wrappedStream = wrappedEntity.getContent();
    pushbackStream = new PushbackInputStream(wrappedStream, 2);
    if (isInputStreamGZIPCompressed(pushbackStream)) {
        gzippedStream = new GZIPInputStream(pushbackStream);
        return gzippedStream;
    } else {
        return pushbackStream;
    }
}

/**
 * Creates a new ZIP input stream.
 *
 * @param in the actual input stream
 */
public ZipInputStream(InputStream in) {
    super(new PushbackInputStream(in, 512), new Inflater(true), 512);
    usesDefaultInflater = true;
    if (in == null) {
        throw new NullPointerException("in is null");
    }
}

private void readEnd(ZipEntry e) throws IOException {
    int n = inf.getRemaining();
    if (n > 0) {
        ((PushbackInputStream) in).unread(buf, len - n, n);
    }
    if ((flag & 8) == 8) {
    /* "Data Descriptor" present */
        readFully(tmpbuf, 0, EXTHDR);
        long sig = get32(tmpbuf, 0);
        if (sig != EXTSIG) { // no EXTSIG present
            e.crc = sig;
            e.csize = get32(tmpbuf, EXTSIZ - EXTCRC);
            e.size = get32(tmpbuf, EXTLEN - EXTCRC);
            ((PushbackInputStream) in).unread(tmpbuf, EXTHDR - EXTCRC - 1, EXTCRC);
        } else {
            e.crc = get32(tmpbuf, EXTCRC);
            e.csize = get32(tmpbuf, EXTSIZ);
            e.size = get32(tmpbuf, EXTLEN);
        }
    }
    if (e.size != inf.getBytesWritten()) {
        throw new ZipException("invalid entry size (expected " + e.size + " but got " + inf.getBytesWritten() + " bytes)");
    }
    if (e.csize != inf.getBytesRead()) {
        throw new ZipException("invalid entry compressed size (expected " + e.csize + " but got " + inf.getBytesRead() + " bytes)");
    }
    if (e.crc != crc.getValue()) {
        throw new ZipException("invalid entry CRC (expected 0x" + Long.toHexString(e.crc) + " but got 0x" + Long.toHexString(crc.getValue()) + ")");
    }
}

public HTTPSession(TempFileManager tempFileManager, InputStream inputStream, OutputStream outputStream, InetAddress inetAddress) {
    this.tempFileManager = tempFileManager;
    this.inputStream = new PushbackInputStream(inputStream, BUFSIZE);
    this.outputStream = outputStream;
    String remoteIp = inetAddress.isLoopbackAddress() || inetAddress.isAnyLocalAddress() ? "127.0.0.1" : inetAddress.getHostAddress().toString();
    headers = new HashMap<String, String>();

    headers.put("remote-addr", remoteIp);
    headers.put("http-client-ip", remoteIp);
}

@Override
public InputStream getContent() throws IOException {
    wrappedStream = wrappedEntity.getContent();
    pushbackStream = new PushbackInputStream(wrappedStream, 2);
    if (isInputStreamGZIPCompressed(pushbackStream)) {
        gzippedStream = new GZIPInputStream(pushbackStream);
        return gzippedStream;
    } else {
        return pushbackStream;
    }
}

/**
 * Decode the text from the InputStream and write the decoded
 * octets to the OutputStream. This method runs until the stream
 * is exhausted.
 * @exception CEFormatException An error has occurred while decoding
 * @exception CEStreamExhausted The input stream is unexpectedly out of data
 */
public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
    int     i;
    int     totalBytes = 0;

    PushbackInputStream ps = new PushbackInputStream (aStream);
    decodeBufferPrefix(ps, bStream);
    while (true) {
        int length;

        try {
            length = decodeLinePrefix(ps, bStream);
            for (i = 0; (i+bytesPerAtom()) < length; i += bytesPerAtom()) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            }
            if ((i + bytesPerAtom()) == length) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            } else {
                decodeAtom(ps, bStream, length - i);
                totalBytes += (length - i);
            }
            decodeLineSuffix(ps, bStream);
        } catch (CEStreamExhausted e) {
            break;
        }
    }
    decodeBufferSuffix(ps, bStream);
}

public PushbackInputStream getInputStream() throws IOException {
    if (input == null) {
        throw new IOException(
                "login session isn't opened or is already closed.");
    }
    return input;
}

private void decodeBuffer(InputStream paramInputStream, OutputStream paramOutputStream) throws IOException {
    PushbackInputStream localPushbackInputStream = new PushbackInputStream(paramInputStream);
    int j = 0;
    while (true) {
        try {
            int k = bytesPerLine();
            int i = 0;
            if (i + bytesPerAtom() < k) {
                decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
                j += bytesPerAtom();
                i += bytesPerAtom();
                continue;
            }

            if (i + bytesPerAtom() == k) {
                decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
                j += bytesPerAtom();
            } else {
                decodeAtom(localPushbackInputStream, paramOutputStream, k - i);
                j += k - i;
            }
        } catch (RuntimeException e) {
            String.valueOf(j);
            break;
        }
    }
}

/**
 * Checks the InputStream if it contains  GZIP compressed data
 *
 * @param inputStream InputStream to be checked
 * @return true or false if the stream contains GZIP compressed data
 * @throws java.io.IOException
 */
public static boolean isInputStreamGZIPCompressed(final PushbackInputStream inputStream) throws IOException {
    if (inputStream == null)
        return false;

    byte[] signature = new byte[2];
    int readStatus = inputStream.read(signature);
    inputStream.unread(signature);
    int streamHeader = ((int) signature[0] & 0xff) | ((signature[1] << 8) & 0xff00);
    return readStatus == 2 && GZIPInputStream.GZIP_MAGIC == streamHeader;
}

public void parse(InputStream stream,
      ContentHandler handler, Metadata metadata,
      ParseContext parseContext) throws IOException, SAXException,
      TikaException 
{
   byte[] initial4 = new byte[4];
   InputStream wrapped;
   // Preserve TikaInputStreams as TikaInputStreams as they require less memory to process
   if (stream.markSupported())
   {
      stream.mark(initial4.length);
      IOUtils.readFully(stream, initial4);
      stream.reset();
      wrapped = stream;
   }
   else
   {
      PushbackInputStream inp = new PushbackInputStream(stream, 4);
      IOUtils.readFully(inp, initial4);
      inp.unread(initial4);
      wrapped = inp;
   }

   // Which is it?
   if(initial4[0] == POIFSConstants.OOXML_FILE_HEADER[0] &&
      initial4[1] == POIFSConstants.OOXML_FILE_HEADER[1] &&
      initial4[2] == POIFSConstants.OOXML_FILE_HEADER[2] &&
      initial4[3] == POIFSConstants.OOXML_FILE_HEADER[3])
   {
      ooxmlParser.parse(wrapped, handler, metadata, parseContext);
   }
   else
   {
      ole2Parser.parse(wrapped, handler, metadata, parseContext);
   }
}

/**
 * 145 * Decode the text from the InputStream and write the decoded 146 *
 * octets to the OutputStream. This method runs until the stream 147 * is
 * exhausted. 148 * @exception CEFormatException An error has occured while
 * decoding 149 * @exception CEStreamExhausted The input stream is
 * unexpectedly out of data 150
 */
public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
    int i;
    @SuppressWarnings("unused")
    int totalBytes = 0;

    PushbackInputStream ps = new PushbackInputStream(aStream);
    decodeBufferPrefix(ps, bStream);
    while (true) {
        int length;

        try {
            length = decodeLinePrefix(ps, bStream);
            for (i = 0; (i + bytesPerAtom()) < length; i += bytesPerAtom()) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            }
            if ((i + bytesPerAtom()) == length) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            } else {
                decodeAtom(ps, bStream, length - i);
                totalBytes += (length - i);
            }
            decodeLineSuffix(ps, bStream);
        } catch (RuntimeException e) {
            break;
        }
    }
    decodeBufferSuffix(ps, bStream);
}

private void decodeBuffer(InputStream paramInputStream, OutputStream paramOutputStream) throws IOException {
    PushbackInputStream localPushbackInputStream = new PushbackInputStream(paramInputStream);
    int j = 0;
    while (true) {
        try {
            int k = bytesPerLine();
            int i = 0;
            if (i + bytesPerAtom() < k) {
                decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
                j += bytesPerAtom();
                i += bytesPerAtom();
                continue;
            }

            if (i + bytesPerAtom() == k) {
                decodeAtom(localPushbackInputStream, paramOutputStream, bytesPerAtom());
                j += bytesPerAtom();
            } else {
                decodeAtom(localPushbackInputStream, paramOutputStream, k - i);
                j += k - i;
            }
        } catch (RuntimeException e) {
            String.valueOf(j);
            break;
        }
    }
}

public static String readLine(PushbackInputStream in) throws IOException {
           char buf[] = new char[128];
           int room = buf.length;
           int offset = 0;
           int c;
loop:       while (true) {
               switch (c = in.read()) {
                   case -1:
                   case '\n':
                       break loop;
                   case '\r':
                       int c2 = in.read();
                       if ((c2 != '\n') && (c2 != -1)) in.unread(c2);
                       break loop;
                   default:
                       if (--room < 0) {
                           char[] lineBuffer = buf;
                           buf = new char[offset + 128];
                           room = buf.length - offset - 1;
                           System.arraycopy((Object)lineBuffer, 0, (Object)buf, 0, offset);  

                       }
                       buf[offset++] = (char) c;
                       break;
               }
           }
           if ((c == -1) && (offset == 0)) return null;
           return String.copyValueOf(buf, 0, offset);
   }

/**
 * Constructs an XmlHeaderAwareReader.
 * 
 * @param in the {@link InputStream}
 * @throws UnsupportedEncodingException if the encoding is not supported
 * @throws IOException occurred while reading the XML header
 * @since 1.3
 */
public XmlHeaderAwareReader(final InputStream in) throws UnsupportedEncodingException, IOException {
    final PushbackInputStream[] pin = new PushbackInputStream[]{in instanceof PushbackInputStream
        ? (PushbackInputStream)in
        : new PushbackInputStream(in, 64)};
    final Map<String, String> header = getHeader(pin);
    version = Double.parseDouble(header.get(KEY_VERSION));
    reader = new InputStreamReader(pin[0], header.get(KEY_ENCODING));
}

/**
 * Decode the text from the InputStream and write the decoded
 * octets to the OutputStream. This method runs until the stream
 * is exhausted.
 * @exception CEFormatException An error has occured while decoding
 * @exception CEStreamExhausted The input stream is unexpectedly out of data
 */
public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
    int     i;
    int     totalBytes = 0;

    PushbackInputStream ps = new PushbackInputStream (aStream);
    decodeBufferPrefix(ps, bStream);
    while (true) {
        int length;

        try {
            length = decodeLinePrefix(ps, bStream);
            for (i = 0; (i+bytesPerAtom()) < length; i += bytesPerAtom()) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            }
            if ((i + bytesPerAtom()) == length) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            } else {
                decodeAtom(ps, bStream, length - i);
                totalBytes += (length - i);
            }
            decodeLineSuffix(ps, bStream);
        } catch (CEStreamExhausted e) {
            break;
        }
    }
    decodeBufferSuffix(ps, bStream);
}

/**
 * decodeLinePrefix reads the sequence number and the number of
 * encoded bytes from the line. If the sequence number is not the
 * previous sequence number + 1 then an exception is thrown.
 * UCE lines are line terminator immune, they all start with *
 * so the other thing this method does is scan for the next line
 * by looking for the * character.
 *
 * @exception CEFormatException out of sequence lines detected.
 */
protected int decodeLinePrefix(PushbackInputStream inStream, OutputStream outStream)  throws IOException {
    int     i;
    int     nLen, nSeq;
    byte    xtmp[];
    int     c;

    crc.value = 0;
    while (true) {
        c = inStream.read(tmp, 0, 1);
        if (c == -1) {
            throw new CEStreamExhausted();
        }
        if (tmp[0] == '*') {
            break;
        }
    }
    lineAndSeq.reset();
    decodeAtom(inStream, lineAndSeq, 2);
    xtmp = lineAndSeq.toByteArray();
    nLen = xtmp[0] & 0xff;
    nSeq = xtmp[1] & 0xff;
    if (nSeq != sequence) {
        throw new CEFormatException("UCDecoder: Out of sequence line.");
    }
    sequence = (sequence + 1) & 0xff;
    return (nLen);
}

/**
 * this method reads the CRC that is at the end of every line and
 * verifies that it matches the computed CRC.
 *
 * @exception CEFormatException if CRC check fails.
 */
protected void decodeLineSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException {
    int i;
    int lineCRC = crc.value;
    int readCRC;
    byte tmp[];

    lineAndSeq.reset();
    decodeAtom(inStream, lineAndSeq, 2);
    tmp = lineAndSeq.toByteArray();
    readCRC = ((tmp[0] << 8) & 0xFF00) + (tmp[1] & 0xff);
    if (readCRC != lineCRC) {
        throw new CEFormatException("UCDecoder: CRC check failed.");
    }
}

/**
 * Checks the InputStream if it contains  GZIP compressed data
 *
 * @param inputStream InputStream to be checked
 * @return true or false if the stream contains GZIP compressed data
 * @throws IOException
 */
public static boolean isInputStreamGZIPCompressed(final PushbackInputStream inputStream) throws IOException {
    if (inputStream == null)
        return false;

    byte[] signature = new byte[2];
    int readStatus = inputStream.read(signature);
    inputStream.unread(signature);
    int streamHeader = ((int) signature[0] & 0xff) | ((signature[1] << 8) & 0xff00);
    return readStatus == 2 && GZIPInputStream.GZIP_MAGIC == streamHeader;
}

/**
 * UUencoded files have a buffer suffix which consists of the word
 * end. This line should immediately follow the line with a single
 * space in it.
 */
protected void decodeBufferSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException  {
    int     c;

    c = inStream.read(decoderBuffer);
    if ((decoderBuffer[0] != 'e') || (decoderBuffer[1] != 'n') ||
        (decoderBuffer[2] != 'd')) {
        throw new CEFormatException("UUDecoder: Missing 'end' line.");
    }
}

static private String detectEncoding(PushbackInputStream in) throws IOException {
  String encoding = UTF8;
  int b1 = in.read();
  if (b1 != -1) {
    int b2 = in.read();
    if (b2 != -1) {
      in.unread(b2);
      if ((b1 == 0xFF && b2 == 0xFE) || (b1 == 0xFE && b2 == 0xFF))
        encoding = UTF16;
    }
    in.unread(b1);
  }
  return encoding;
}

/**
 * Decode the text from the InputStream and write the decoded
 * octets to the OutputStream. This method runs until the stream
 * is exhausted.
 * @exception CEFormatException An error has occurred while decoding
 * @exception CEStreamExhausted The input stream is unexpectedly out of data
 */
public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
    int     i;
    int     totalBytes = 0;

    PushbackInputStream ps = new PushbackInputStream (aStream);
    decodeBufferPrefix(ps, bStream);
    while (true) {
        int length;

        try {
            length = decodeLinePrefix(ps, bStream);
            for (i = 0; (i+bytesPerAtom()) < length; i += bytesPerAtom()) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            }
            if ((i + bytesPerAtom()) == length) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            } else {
                decodeAtom(ps, bStream, length - i);
                totalBytes += (length - i);
            }
            decodeLineSuffix(ps, bStream);
        } catch (CEStreamExhausted e) {
            break;
        }
    }
    decodeBufferSuffix(ps, bStream);
}

/**
 * decodeLinePrefix reads the sequence number and the number of
 * encoded bytes from the line. If the sequence number is not the
 * previous sequence number + 1 then an exception is thrown.
 * UCE lines are line terminator immune, they all start with *
 * so the other thing this method does is scan for the next line
 * by looking for the * character.
 *
 * @exception CEFormatException out of sequence lines detected.
 */
protected int decodeLinePrefix(PushbackInputStream inStream, OutputStream outStream)  throws IOException {
    int     i;
    int     nLen, nSeq;
    byte    xtmp[];
    int     c;

    crc.value = 0;
    while (true) {
        c = inStream.read(tmp, 0, 1);
        if (c == -1) {
            throw new CEStreamExhausted();
        }
        if (tmp[0] == '*') {
            break;
        }
    }
    lineAndSeq.reset();
    decodeAtom(inStream, lineAndSeq, 2);
    xtmp = lineAndSeq.toByteArray();
    nLen = xtmp[0] & 0xff;
    nSeq = xtmp[1] & 0xff;
    if (nSeq != sequence) {
        throw new CEFormatException("UCDecoder: Out of sequence line.");
    }
    sequence = (sequence + 1) & 0xff;
    return (nLen);
}

/**
 * this method reads the CRC that is at the end of every line and
 * verifies that it matches the computed CRC.
 *
 * @exception CEFormatException if CRC check fails.
 */
protected void decodeLineSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException {
    int i;
    int lineCRC = crc.value;
    int readCRC;
    byte tmp[];

    lineAndSeq.reset();
    decodeAtom(inStream, lineAndSeq, 2);
    tmp = lineAndSeq.toByteArray();
    readCRC = ((tmp[0] << 8) & 0xFF00) + (tmp[1] & 0xff);
    if (readCRC != lineCRC) {
        throw new CEFormatException("UCDecoder: CRC check failed.");
    }
}

/**
 * 装饰一下，返回可以重读的InputStream
 *
 * @return dummy
 * @throws IOException
 */
@Override
public InputStream getBody() throws IOException {

    InputStream body = this.delegate.getBody();
    if (body == null || body.markSupported() || body instanceof PushbackInputStream) {
        return body;
    } else if (this.pushbackInputStream == null) {
        this.pushbackInputStream = new PushbackInputStream(body, WX_API_ERROR_CODE_END);
    }
    return this.pushbackInputStream;
}

@Override
public InputStream getContent() throws IOException {
    wrappedStream = wrappedEntity.getContent();
    pushbackStream = new PushbackInputStream(wrappedStream, 2);
    if (isInputStreamGZIPCompressed(pushbackStream)) {
        gzippedStream = new GZIPInputStream(pushbackStream);
        return gzippedStream;
    } else {
        return pushbackStream;
    }
}

/**
 * UUencoded files have a buffer suffix which consists of the word
 * end. This line should immediately follow the line with a single
 * space in it.
 */
protected void decodeBufferSuffix(PushbackInputStream inStream, OutputStream outStream) throws IOException  {
    int     c;

    c = inStream.read(decoderBuffer);
    if ((decoderBuffer[0] != 'e') || (decoderBuffer[1] != 'n') ||
        (decoderBuffer[2] != 'd')) {
        throw new CEFormatException("UUDecoder: Missing 'end' line.");
    }
}

static private String detectEncoding(PushbackInputStream in) throws IOException {
  String encoding = UTF8;
  int b1 = in.read();
  if (b1 != -1) {
    int b2 = in.read();
    if (b2 != -1) {
      in.unread(b2);
      if ((b1 == 0xFF && b2 == 0xFE) || (b1 == 0xFE && b2 == 0xFF))
        encoding = UTF16;
    }
    in.unread(b1);
  }
  return encoding;
}

/**
 * 145 * Decode the text from the InputStream and write the decoded 146 *
 * octets to the OutputStream. This method runs until the stream 147 * is
 * exhausted. 148 * @exception CEFormatException An error has occured while
 * decoding 149 * @exception CEStreamExhausted The input stream is
 * unexpectedly out of data 150
 */
public void decodeBuffer(InputStream aStream, OutputStream bStream) throws IOException {
    int i;
    @SuppressWarnings("unused")
    int totalBytes = 0;

    PushbackInputStream ps = new PushbackInputStream(aStream);
    decodeBufferPrefix(ps, bStream);
    while (true) {
        int length;

        try {
            length = decodeLinePrefix(ps, bStream);
            for (i = 0; (i + bytesPerAtom()) < length; i += bytesPerAtom()) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            }
            if ((i + bytesPerAtom()) == length) {
                decodeAtom(ps, bStream, bytesPerAtom());
                totalBytes += bytesPerAtom();
            } else {
                decodeAtom(ps, bStream, length - i);
                totalBytes += (length - i);
            }
            decodeLineSuffix(ps, bStream);
        } catch (RuntimeException e) {
            break;
        }
    }
    decodeBufferSuffix(ps, bStream);
}

public InputStream getContent() throws IOException {
    this.wrappedStream = this.wrappedEntity.getContent();
    this.pushbackStream = new PushbackInputStream(this.wrappedStream, 2);
    if (!AsyncHttpClient.isInputStreamGZIPCompressed(this.pushbackStream)) {
        return this.pushbackStream;
    }
    this.gzippedStream = new GZIPInputStream(this.pushbackStream);
    return this.gzippedStream;
}