import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Test
public void allFloatParameterCombinationsKnockout() throws IOException {
    final List<float[]> fullData = loadFullFloatData();

    try (BufferedWriter noSplitWriter = openWriter("floats-knockout-nosplit");
         BufferedWriter splitWriter = openWriter("floats-knockout")) {
        for (float knockout : new float[] { 0f, 0.1f, 0.5f, 0.75f }) {
            final Random r = new Random(1337);
            final List<float[]> check = fullData.stream().map(xs -> {
                final float[] ys = xs.clone();
                for (int i = 0; i < ys.length; i++) {
                    if (r.nextDouble() < knockout) {
                        ys[i] = Float.NaN;
                    }
                }
                return ys;
            }).collect(Collectors.toList());

            allFloatParameterCombinationsWork(check, "Snappy\t" + knockout, SnappyOutputStream::new, SnappyInputStream::new, noSplitWriter, splitWriter);
        }
    }
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Test
public void allDoubleParameterCombinationsKnockout() throws IOException {
    final List<double[]> fullData = loadFullDoubleData();

    try (BufferedWriter noSplitWriter = openWriter("doubles-knockout-nosplit");
         BufferedWriter splitWriter = openWriter("doubles-knockout")) {
        for (float knockout : new float[] { 0f, 0.1f, 0.5f, 0.75f }) {
            final Random r = new Random(1337);
            final List<double[]> check = fullData.stream().map(xs -> {
                final double[] ys = xs.clone();
                for (int i = 0; i < ys.length; i++) {
                    if (r.nextDouble() < knockout) {
                        ys[i] = Double.NaN;
                    }
                }
                return ys;
            }).collect(Collectors.toList());

            allDoubleParameterCombinationsWork(check, "Snappy\t" + knockout, SnappyOutputStream::new, SnappyInputStream::new, noSplitWriter, splitWriter);
        }
    }
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Nonnull
private static byte[] archiveState(@Nonnull Element state) {
  BufferExposingByteArrayOutputStream byteOut = new BufferExposingByteArrayOutputStream();
  try {
    OutputStreamWriter writer = new OutputStreamWriter(new SnappyOutputStream(byteOut), CharsetToolkit.UTF8_CHARSET);
    try {
      XMLOutputter xmlOutputter = new JDOMUtil.MyXMLOutputter();
      xmlOutputter.setFormat(XML_FORMAT);
      xmlOutputter.output(state, writer);
    }
    finally {
      writer.close();
    }
  }
  catch (IOException e) {
    throw new StateStorageException(e);
  }
  return ArrayUtil.realloc(byteOut.getInternalBuffer(), byteOut.size());
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Test
public void benchmark() throws IOException {
    /*
    Snappy compress: 0.156672s
    Compressed to 10876881 bytes
    Uncompresses to 12908620 bytes
    Snappy decompress: 0.162463s

    Deflate Fastest compress: 6.017877s
    Compressed to 7770401 bytes
    Uncompresses to 12908620 bytes
    Deflate Fastest decompress: 4.260146s

    Deflate Slowest compress: 7.06043s
    Compressed to 7492001 bytes
    Uncompresses to 12908620 bytes
    Deflate Slowest decompress: 3.968221s

    Deflate Normal compress: 5.201332s
    Compressed to 7515522 bytes
    Uncompresses to 12908620 bytes
    Deflate Normal decompress: 4.056792s
     */
    benchmark("None",            x -> x,                                                                         x -> x);
    benchmark("None",            x -> x,                                                                         x -> x);
    benchmark("Snappy",          SnappyOutputStream::new,                                                        SnappyInputStream::new);
    benchmark("GZip",            GZIPOutputStream::new,                                                          GZIPInputStream::new);
    benchmark("Deflate Fastest", os -> new DeflaterOutputStream(os, new Deflater(Deflater.BEST_SPEED)),          InflaterInputStream::new);
    benchmark("Deflate Normal",  os -> new DeflaterOutputStream(os, new Deflater(Deflater.DEFAULT_COMPRESSION)), InflaterInputStream::new);
    benchmark("Deflate Slowest", os -> new DeflaterOutputStream(os, new Deflater(Deflater.BEST_COMPRESSION)),    InflaterInputStream::new);
    benchmark("BZip2 Fastest",   os -> new BZip2CompressorOutputStream(os, BZip2CompressorOutputStream.MIN_BLOCKSIZE), BZip2CompressorInputStream::new);
    benchmark("BZip2 Slowest",   os -> new BZip2CompressorOutputStream(os, BZip2CompressorOutputStream.MAX_BLOCKSIZE), BZip2CompressorInputStream::new);
    benchmark("XZ Fastest",      os -> new XZCompressorOutputStream(os, LZMA2Options.PRESET_MIN),                      XZCompressorInputStream::new);
    benchmark("XZ Normal",       os -> new XZCompressorOutputStream(os, LZMA2Options.PRESET_DEFAULT),                  XZCompressorInputStream::new);
    benchmark("XZ Slowest",      os -> new XZCompressorOutputStream(os, LZMA2Options.PRESET_MAX),                      XZCompressorInputStream::new);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Test
public void allFloatParameterCombinationsWork() throws IOException {
    try (BufferedWriter noSplitWriter = openWriter("floats-nosplit");
         BufferedWriter splitWriter = openWriter("floats")) {
        allFloatParameterCombinationsWork(loadFullFloatData(), "Snappy", SnappyOutputStream::new,                                                              SnappyInputStream::new,          noSplitWriter, splitWriter);
        allFloatParameterCombinationsWork(loadFullFloatData(), "BZ2",    os -> new BZip2CompressorOutputStream(os, BZip2CompressorOutputStream.MIN_BLOCKSIZE), BZip2CompressorInputStream::new, noSplitWriter, splitWriter);
    }
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Test
public void allDoubleParameterCombinationsWork() throws IOException {
    try (BufferedWriter noSplitWriter = openWriter("doubles-nosplit");
         BufferedWriter splitWriter = openWriter("doubles")) {
        allDoubleParameterCombinationsWork(loadFullDoubleData(), "Snappy", SnappyOutputStream::new,                                                              SnappyInputStream::new,          noSplitWriter, splitWriter);
        allDoubleParameterCombinationsWork(loadFullDoubleData(), "BZ2",    os -> new BZip2CompressorOutputStream(os, BZip2CompressorOutputStream.MIN_BLOCKSIZE), BZip2CompressorInputStream::new, noSplitWriter, splitWriter);
    }
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
void writeBlock(int[] block, int blockNo, String name) throws Exception {
	String directory = index.cacheDir;
	File f = index.getFilesInterface().createFile(
			directory + File.separator + name + File.separator + blockNo);
	if (f.exists()) {
		File savedDir = index.getFilesInterface().createFile(
				directory + File.separator + "saved-" + name);
		savedDir.mkdirs();
		File savedF = index.getFilesInterface().createFile(
				directory + File.separator + "saved-" + name
						+ File.separator + blockNo);
		int i = 1;
		while (savedF.exists()) {
			savedF = index.getFilesInterface().createFile(
					directory + File.separator + "saved-" + name
							+ File.separator + blockNo + "-" + i++);
		}
		f.renameTo(savedF);
	}
	OutputStream writer = index.getFilesInterface().createOutputStream(f);
	DataOutputStream stream = new DataOutputStream(new SnappyOutputStream(
			writer));
	// writer);

	int sz = block[0];
	if (tmpBuffer.length < sz * 4) {
		tmpBuffer = new byte[sz * 4];
		intBuffer = ByteBuffer.wrap(tmpBuffer).asIntBuffer();
	}

	intBuffer.rewind();
	intBuffer.put(block, 0, sz);
	stream.write(tmpBuffer, 0, sz * 4);
	stream.close();
	writer.close();
	trimFile(f);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
private static FDataOutput createStream(File cacheFile)
		throws FileNotFoundException, IOException {
	cacheFile.deleteOnExit();

	OutputStream fout = new SnappyOutputStream(new BufferedOutputStream(
			new FileOutputStream(cacheFile)));
	return new FDataOutput(fout);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
public void saveContent(@Nonnull String fileSpec, @Nonnull RoamingType roamingType, byte[] content, int size) throws IOException {
  UnsyncByteArrayOutputStream out = new UnsyncByteArrayOutputStream(size);
  try (SnappyOutputStream snappyOutputStream = new SnappyOutputStream(out)) {
    snappyOutputStream.write(content, 0, size);
  }

  byte[] compressedContent = out.toByteArray();

  myQueue.wantSave(myProxyDirectory, fileSpec, roamingType, compressedContent);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Override
public void init(File file) {
	try {
		os = new DataOutputStream(new SnappyOutputStream(
				new BufferedOutputStream(new FileOutputStream(file),
						65536)));
	} catch (Exception e) {
		log.error("Error", e);
	}
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
public OutputStream(java.io.OutputStream stream) throws IOException {
  myUnderlyingOutputStream = new SnappyOutputStream(stream);
  myOutputStream = new CompactDataOutput(myUnderlyingOutputStream);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Benchmark
public int snappy() throws IOException {
    return benchmark(SnappyOutputStream::new,                                                        SnappyInputStream::new);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
@Override
public OutputStream output(OutputStream out) throws IOException {
    return new SnappyOutputStream(out);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
void writeListBlockToFile(ListBlocks b, int no, boolean writeBlocks)
		throws Exception {
	String name = "lb-" + no;
	File file = index.getFilesInterface().createFile(
			index.cacheDir + "/" + name);
	if (!file.mkdirs() && (!file.exists() || !file.isDirectory())) {
		log.warn(index.cacheDir + File.separator + name
				+ ": could not create");
		/*
		 * Don't make this a fatal error ... --Ceriel throw new
		 * IOException("Could not create" + index.cacheDir + File.separator
		 * + name);
		 */
	}
	file = index.getFilesInterface().createFile(
			index.cacheDir + "/" + name + "/index");
	if (log.isDebugEnabled()) {
		log.debug("write index of ListBlock " + index.cacheDir + "/" + name);
	}
	if (file.exists()) {
		File savedDir = index.getFilesInterface().createFile(
				index.cacheDir + "/" + "saved-" + name);
		savedDir.mkdirs();
		File savedF = index.getFilesInterface().createFile(
				index.cacheDir + "/" + "saved-" + name + "/index");
		int i = 1;
		while (savedF.exists()) {
			savedF = index.getFilesInterface().createFile(
					index.cacheDir + "/" + "saved-" + name + "/index-"
							+ i++);
		}
		file.renameTo(savedF);
	}
	OutputStream writer = index.getFilesInterface()
			.createOutputStream(file);
	DataOutputStream stream = new DataOutputStream(new SnappyOutputStream(
			writer));
	// writer);
	b.writeTo(stream, writeBlocks);
	stream.flush();
	stream.close();
	writer.flush();
	writer.close();
	trimFile(file);
}
 

import org.iq80.snappy.SnappyOutputStream; //导入依赖的package包/类
protected OutputStream wrapOutputStream(OutputStream underlying) throws IOException {
    return new SnappyOutputStream(underlying);
}