How to use

read

method

in

org.xerial.snappy.SnappyInputStream

/**
 * Read int array from the stream
 *
 * @param d
 * @return the total number of bytes read into the buffer, or -1 if there is
 * no more data because the end of the stream has been reached.
 * @throws IOException
 */
public int read(int[] d)
    throws IOException
{
  return read(d, 0, d.length);
}

/**
 * Read long array from the stream
 *
 * @param d
 * @return the total number of bytes read into the buffer, or -1 if there is
 * no more data because the end of the stream has been reached.
 * @throws IOException
 */
public int read(long[] d)
    throws IOException
{
  return read(d, 0, d.length);
}

/**
 * Read float array from the stream
 *
 * @param d
 * @return the total number of bytes read into the buffer, or -1 if there is
 * no more data because the end of the stream has been reached.
 * @throws IOException
 */
public int read(float[] d)
    throws IOException
{
  return read(d, 0, d.length);
}

/**
 * Read short array from the stream
 *
 * @param d
 * @return the total number of bytes read into the buffer, or -1 if there is
 * no more data because the end of the stream has been reached.
 * @throws IOException
 */
public int read(short[] d)
    throws IOException
{
  return read(d, 0, d.length);
}

/**
 * Read double array from the stream
 *
 * @param d
 * @return the total number of bytes read into the buffer, or -1 if there is
 * no more data because the end of the stream has been reached.
 * @throws IOException
 */
public int read(double[] d)
    throws IOException
{
  return read(d, 0, d.length);
}

@Override
public int read() throws IOException {
 return ( (SnappyInputStream) delegate ).read();
}

  private void decompress(InputStream input, OutputStream output) throws IOException {
    byte data[] = new byte[BUFFER];
    try (BufferedOutputStream dest1 = new BufferedOutputStream(output, BUFFER);
        SnappyInputStream is = new SnappyInputStream(new BufferedInputStream(input))) {
      int c;
      while ((c = is.read(data, 0, BUFFER)) != -1) {
        dest1.write(data, 0, c);
      }
    }
  }
}

/**
 * Reads the next byte of uncompressed data from the input stream. The value
 * byte is returned as an int in the range 0 to 255. If no byte is available
 * because the end of the stream has been reached, the value -1 is returned.
 * This method blocks until input data is available, the end of the stream
 * is detected, or an exception is thrown.
 */
/* (non-Javadoc)
 * @see java.io.InputStream#read()
 */
@Override
public int read()
    throws IOException
{
  if (uncompressedCursor < uncompressedLimit) {
    return uncompressed[uncompressedCursor++] & 0xFF;
  }
  else {
    if (hasNextChunk()) {
      return read();
    }
    else {
      return -1;
    }
  }
}

int read = snappyIn.read(buf);
if (read == -1) {
 break;

while ((len = sis.read(buffer)) > 0) {
  out.write(buffer, 0, len);

public Decompress(File in, File out) {
  long begin = System.currentTimeMillis();
  logger.info("decompressing" + new Date() + "...");
  logger.info("in:\t" + in + " (" + df.format(in.length()) + ")");
  logger.info("out:\t" + out);
  byte[] buffer = new byte[1024];
  try {
    SnappyInputStream sis = new SnappyInputStream(new FileInputStream(in));
    FileOutputStream fos = new FileOutputStream(out);
    int len;
    while ((len = sis.read(buffer)) > 0) {
      fos.write(buffer, 0, len);
    }
    sis.close();
    fos.close();
  } catch (IOException e) {
    logger.error(e);
  }
  long end = System.currentTimeMillis();
  logger.info("decompression done in " + df.format(end - begin) + " ms (" + new Date() + ")");
}

  @Override
  public void decompress(InputStream source, OutputStream destination)
      throws IOException {
    SnappyInputStream compressedInputStream = null;
    BufferedOutputStream output = null;
    try {
      compressedInputStream = new SnappyInputStream(
          new BufferedInputStream(source));
      output = new BufferedOutputStream(destination, DEFAULT_BUFFER_SIZE);

      int bytesRead;
      byte[] data = new byte[DEFAULT_BUFFER_SIZE];
      while ((bytesRead = compressedInputStream.read(data, 0,
          DEFAULT_BUFFER_SIZE)) != -1) {
        output.write(data, 0, bytesRead);
      }
    } finally {
      IOUtils.closeQuietly(compressedInputStream);
      IOUtils.closeQuietly(output);
    }
  }
}

int read = snappyIn.read(buf);
if (read == -1) {
 break;

value = snappy.read();
if (value != -1) {
  baos.write(value);