Java Code Examples for java.io.OutputStream

public OutputStream createDataStream()
{
    if (absDataFile.exists())
    {
        if (overwrite == false)
        {
            throw new ExporterException("Package data file " + absDataFile.getAbsolutePath() + " already exists.");
        }
        log("Warning: Overwriting existing package file " + absDataFile.getAbsolutePath());
        absDataFile.delete();
    }

    try
    {
        absDataFile.createNewFile();
        absDataStream = new FileOutputStream(absDataFile);
        return absDataStream;
    }
    catch(IOException e)
    {
        throw new ExporterException("Failed to create package file " + absDataFile.getAbsolutePath() + " due to " + e.getMessage());
    }
}
 

public void save(OutputStream outStream, boolean sorted) throws IOException {
	if (!sorted) {
		save(outStream);
		return;
	}
    BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream, "UTF-8"));
    String aKey;
    Object aValue;
    TreeMap tm = new TreeMap(this);
    for (Iterator i = tm.keySet().iterator(); i.hasNext();) {
        aKey = (String) i.next();
        aValue = get(aKey);
        out.write(aKey + " = " + aValue);
        out.newLine();
    }
    out.flush();
    out.close();
}
 

private void writeComment(OutputStream os, String comment) throws Exception {
	os.write(EXTENSION_INTRODUCER);
	os.write(COMMENT_EXTENSION_LABEL);
	byte[] commentBytes = comment.getBytes();
	int numBlocks = commentBytes.length/0xff;
	int leftOver = commentBytes.length % 0xff;
	int offset = 0;
	if(numBlocks > 0) {
		for(int i = 0; i < numBlocks; i++) {
			os.write(0xff);
			os.write(commentBytes, offset, 0xff);
			offset += 0xff;
		}
	}
	if(leftOver > 0) {
		os.write(leftOver);
		os.write(commentBytes, offset, leftOver);
	}
	os.write(0);
}
 

public void train() {
    try {
        InputStreamFactory modelStream = new MarkableFileInputStreamFactory(
                new File(getClass().getClassLoader().getResource(TRAIN_INPUT).getFile())
        );
        final ObjectStream<String> lineStream = new PlainTextByLineStream(modelStream, "UTF-8");
        final ObjectStream<DocumentSample> sampleStream = new DocumentSampleStream(lineStream);

        final TrainingParameters mlParams = new TrainingParameters();
        mlParams.put(TrainingParameters.ITERATIONS_PARAM, 5000);
        mlParams.put(TrainingParameters.CUTOFF_PARAM, 5);

        final DoccatModel model = DocumentCategorizerME.train("en", sampleStream, mlParams, new DoccatFactory());
        final Path path = Paths.get(MODEL_OUTPUT);
        FileUtils.touch(path.toFile());
        try (OutputStream modelOut = new BufferedOutputStream(new FileOutputStream(path.toString()))) {
            model.serialize(modelOut);
        }
    } catch (Exception e) {
        LOGGER.error("an error occurred while training the sentiment analysis model", e);
        throw new IllegalStateException(e);
    }
}
 

/**
 * Saves a chart to a file in PNG format.  This method allows you to pass 
 * in a {@link ChartRenderingInfo} object, to collect information about the 
 * chart dimensions/entities.  You will need this info if you want to 
 * create an HTML image map.
 *
 * @param file  the file (<code>null</code> not permitted).
 * @param chart  the chart (<code>null</code> not permitted).
 * @param width  the image width.
 * @param height  the image height.
 * @param info  the chart rendering info (<code>null</code> permitted).
 *
 * @throws IOException if there are any I/O errors.
 */
public static void saveChartAsPNG(File file, JFreeChart chart,
        int width, int height, ChartRenderingInfo info) 
    throws IOException {

    if (file == null) {
        throw new IllegalArgumentException("Null 'file' argument.");
    }
    OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
    try {
        ChartUtilities.writeChartAsPNG(out, chart, width, height, info);
    }
    finally {
        out.close();
    }
}
 

public void printCounts(OutputStream out, boolean deltas) {
	PrintStream pout = new PrintStream(out);

	Iterator<Key> j = countMap.keySet().iterator();
	while (j.hasNext()) {
		Key key = j.next();
		int count = countMap.get(key).intValue();

		if (count != 0) {
			pout.print(key + ":\t");
			if (deltas && count > 0)
				pout.print("+");
			pout.println(count);
		}
	}
	pout.flush();
}
 

/**
 * Generates the necessary files for the forms upload to the SeaBioData repository
 */
private void dispatchSBDExport() throws IOException {


    SharedPreferences settings = getSharedPreferences(getString(R.string.app_name), MODE_PRIVATE);

    if (!settings.contains(Utils.TAG_SBD_USERNAME)) {
        Toast.makeText(this, getString(R.string.sbd_username_missing_export), Toast.LENGTH_SHORT).show();
        return;
    }

    HashMap<String, ArrayList<FormInstance>> groupedInstances = new HashMap<>();
    for (FormInstance fi : currentItem.getLinkedForms()) {
        if (groupedInstances.containsKey(fi.getParent())) {
            groupedInstances.get(fi.getParent()).add(fi);
            continue;
        }

        ArrayList<FormInstance> newInstances = new ArrayList<>();
        newInstances.add(fi);
        groupedInstances.put(fi.getParent(), newInstances);
    }


    for (String key : groupedInstances.keySet()) {
        FormExportItem exportItem = new FormExportItem(groupedInstances.get(key), settings.getString(Utils.TAG_SBD_USERNAME, ""));
        File file = new File(Environment.getExternalStorageDirectory() + File.separator + key + "_" + new Date().toString() + ".json");

        if(file.createNewFile()) {
            OutputStream fo = new FileOutputStream(file);
            fo.write(new Gson().toJson(exportItem).getBytes());
            fo.close();
        }
    }

    Toast.makeText(getApplicationContext(), getString(R.string.sbd_dorms_exported_successfully), Toast.LENGTH_SHORT).show();
}
 

/**
 * Writes a stream of bytes representing an audio file of the specified file type
 * to the output stream provided.  Some file types require that
 * the length be written into the file header; such files cannot be written from
 * start to finish unless the length is known in advance.  An attempt
 * to write a file of such a type will fail with an IOException if the length in
 * the audio file type is <code>AudioSystem.NOT_SPECIFIED</code>.
 *
 * @param stream the audio input stream containing audio data to be
 * written to the file
 * @param fileType the kind of audio file to write
 * @param out the stream to which the file data should be written
 * @return the number of bytes written to the output stream
 * @throws IOException if an input/output exception occurs
 * @throws IllegalArgumentException if the file type is not supported by
 * the system
 * @see #isFileTypeSupported
 * @see     #getAudioFileTypes
 */
public static int write(AudioInputStream stream, AudioFileFormat.Type fileType,
                        OutputStream out) throws IOException {

    List providers = getAudioFileWriters();
    int bytesWritten = 0;
    boolean flag = false;

    for(int i=0; i < providers.size(); i++) {
        AudioFileWriter writer = (AudioFileWriter) providers.get(i);
        try {
            bytesWritten = writer.write( stream, fileType, out ); // throws IOException
            flag = true;
            break;
        } catch (IllegalArgumentException e) {
            // thrown if this provider cannot write the sequence, try the next
            continue;
        }
    }
    if(!flag) {
        throw new IllegalArgumentException("could not write audio file: file type not supported: " + fileType);
    } else {
        return bytesWritten;
    }
}
 

@Override
public void writeTo(OutputStream out) throws IOException {
    // Begin the map/object/array/whatever exactly this is
    out.write(AmfType.MAP.getValue());

    // Write the "array size"
    Util.writeUnsignedInt32(out, properties.size());

    // Write key/value pairs in this object        
    for (Map.Entry<String, AmfData> entry : properties.entrySet()) {
        // The key must be a STRING type, and thus the "type-definition" byte is implied (not included in message)
        AmfString.writeStringTo(out, entry.getKey(), true);
        entry.getValue().writeTo(out);
    }

    // End the object        
    out.write(OBJECT_END_MARKER);
}
 

private void saveXml(
        final OutputStream out) throws IOException {
    final PrintWriter writer =
            new PrintWriter(new OutputStreamWriter(out, ENCODING));
    
    writer.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
    writer.println("<files-list>");
    
    for (FileEntry entry: this) {
        if (entry.getFile().exists() && !entry.isMetaDataReady()) {
            entry.calculateMetaData();
        }
        
        writer.println("    " + entry.toXml());
    }
    
    writer.println("</files-list>");
    
    writer.flush();
}
 

public void getImage(OutputStream outputStream, String plantId, String uploadID) {
        try {
            Document filterDoc = new Document();

            filterDoc.append("id", plantId);
            filterDoc.append("uploadID", uploadID);

            Iterator<Document> iter = plantCollection.find(filterDoc).iterator();

            Document plant = iter.next();
            String filePath = plant.getString("photoLocation");

//            String filePath = ".photos" + '/' + plantId + ".png";
            File file = new File(filePath);
            try {
                BufferedImage photo = ImageIO.read(file);
                ImageIO.write(photo,"JPEG",outputStream);
            } catch (IIOException e) {}

        }
        catch (IOException ioe) {
            ioe.printStackTrace();
            System.err.println("Could not write some Images to disk, exiting.");
        }
    }
 

/**
 * 执行shell命令
 *
 * @param cmd
 */
private void execShellCmd(String cmd) {

    try {
        // 申请获取root权限，这一步很重要，不然会没有作用
        Process process = Runtime.getRuntime().exec("su");
        // 获取输出流
        OutputStream outputStream = process.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(
                outputStream);
        dataOutputStream.writeBytes(cmd);
        dataOutputStream.flush();
        dataOutputStream.close();
        outputStream.close();
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

public void testShowItIsPossibleToPassInBeansWrappedObject() throws Exception {
    FileObject root = FileUtil.createMemoryFileSystem().getRoot();
    FileObject fo = FileUtil.createData(root, "simpleObject.txt");
    OutputStream os = fo.getOutputStream();
    String txt = "<#if (classInfo.getMethods().size() > 0) >The size is greater than 0.</#if>";
    os.write(txt.getBytes());
    os.close();       
    
    
    StringWriter w = new StringWriter();
                    
    Map<String,Object> parameters = Collections.<String,Object>singletonMap(
        "classInfo", BeansWrapper.getDefaultInstance().wrap(new ClassInfo())
    );
    apply(fo, w, parameters);
    assertEquals("The size is greater than 0.", w.toString());
}
 

void initContents(OutputStream out) throws IOException {
    for (int i = 0; i < size; i++) {
        out.write(byteBuf);
    }
    out.write(new byte[4]); // add the 4 byte pad
    out.flush();
}
 

@Override
public synchronized OutputStream createCompressionStream(
    OutputStream downStream, Compressor compressor,
    int downStreamBufferSize) throws IOException {
  if (downStreamBufferSize > 0) {
    return new BufferedOutputStream(downStream, downStreamBufferSize);
  }

  return downStream;
}
 

@Test
public void testWriteAndRead() throws Exception {
	// Generate a random tag
	byte[] tag = TestUtils.getRandomBytes(TAG_LENGTH);
	// Generate two frames with random payloads
	byte[] payload1 = TestUtils.getRandomBytes(123);
	byte[] payload2 = TestUtils.getRandomBytes(321);
	// Write the tag and the frames
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	StreamEncrypter encrypter = new TestStreamEncrypter(out, tag);
	OutputStream streamWriter = new StreamWriterImpl(encrypter);
	streamWriter.write(payload1);
	streamWriter.flush();
	streamWriter.write(payload2);
	streamWriter.flush();
	byte[] output = out.toByteArray();
	assertEquals(TAG_LENGTH + STREAM_HEADER_LENGTH
			+ FRAME_HEADER_LENGTH  + payload1.length + MAC_LENGTH
			+ FRAME_HEADER_LENGTH  + payload2.length + MAC_LENGTH,
			output.length);
	// Read the tag back
	ByteArrayInputStream in = new ByteArrayInputStream(output);
	byte[] recoveredTag = new byte[tag.length];
	read(in, recoveredTag);
	assertArrayEquals(tag, recoveredTag);
	// Read the frames back
	StreamDecrypter decrypter = new TestStreamDecrypter(in);
	InputStream streamReader = new StreamReaderImpl(decrypter);
	byte[] recoveredPayload1 = new byte[payload1.length];
	read(streamReader, recoveredPayload1);
	assertArrayEquals(payload1, recoveredPayload1);
	byte[] recoveredPayload2 = new byte[payload2.length];
	read(streamReader, recoveredPayload2);
	assertArrayEquals(payload2, recoveredPayload2);
	streamWriter.close();
	streamReader.close();
}
 

/**
 * Returns an {@link java.io.OutputStream OutputStream} that can
 * be used for storing the contents of the file.
 *
 * @return An {@link java.io.OutputStream OutputStream} that can be used
 *         for storing the contensts of the file.
 *
 * @exception IOException if an error occurs.
 */
public OutputStream getOutputStream()
    throws IOException
{
    if (dfos == null)
    {
        File outputFile = getTempFile();
        dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);
    }
    return dfos;
}
 

public Data transform(Data data, XMLCryptoContext xc, OutputStream os)
    throws TransformException
{
    if (data == null) {
        throw new NullPointerException("data must not be null");
    }
    if (os == null) {
        throw new NullPointerException("output stream must not be null");
    }
    return transformIt(data, xc, os);
}
 

@Override
public void writeTo(OutputStream out) throws IOException, MessagingException {
    if (text != null) {
        byte[] bytes = text.getBytes(charset);
        if (MimeUtil.ENC_QUOTED_PRINTABLE.equalsIgnoreCase(encoding)) {
            writeSignSafeQuotedPrintable(out, bytes);
        } else if (MimeUtil.ENC_8BIT.equalsIgnoreCase(encoding)) {
            out.write(bytes);
        } else {
            throw new IllegalStateException("Cannot get size for encoding!");
        }
    }
}
 

@Override
public ByteSource createSource(byte[] bytes) throws IOException {
  checkNotNull(bytes);
  File file = createFile();
  OutputStream out = new FileOutputStream(file);
  try {
    out.write(bytes);
  } finally {
    out.close();
  }
  return Files.asByteSource(file);
}
 

/**
 * Saves current default values into <CODE>FILENAME</CODE>
 * @return true iff file was correctly saved
 */
public static boolean save() {
	boolean saved = false;
	try {
		OutputStream output = new FileOutputStream(new File(getWorkingPath(), FILENAME));
		prop.store(output, "JMT Default parameters definition");
		saved = true;
		output.close();
	} catch (IOException e) {
		logger.error("Error while storing default values", e);
	}
	return saved;
}
 

@Override
public OutputStream outputStream() throws IOException {
    synchronized (this) {
        checkNotClosed();
        return outputStream;
    }
}
 

/**
 * Formats the given wallet (transactions and keys) to the given output stream in protocol buffer format.<p>
 *
 * Equivalent to <tt>walletToProto(wallet).writeTo(output);</tt>
 */
public void writeWallet(Wallet wallet, OutputStream output) throws IOException {
    Protos.Wallet walletProto = walletToProto(wallet);
    final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, this.walletWriteBufferSize);
    walletProto.writeTo(codedOutput);
    codedOutput.flush();
}
 

@Test
public void givenOutputStreamSetup_whenLogExecutedOnMainThread_thenVerifyExpectedOutput() {
    // given
    OutputStream outputStream = LogTesterTestUtils.setupConsoleOutputStream();

    // when
    LogTester.log(mLogType, mMessage);

    // then
    LogTesterTestUtils.assertOutput(outputStream, mExpectedOutput);
}
 

public static void copyFile(File source, File target) throws IOException {
    try (
            InputStream in = new FileInputStream(source);
            OutputStream out = new FileOutputStream(target)) {
        byte[] buf = new byte[1024];
        int length;
        while ((length = in.read(buf)) > 0) {
            out.write(buf, 0, length);
        }
    }
}
 

@Override
public void writeTo(
        final Widget widget,
        final Class<?> type,
        final Type genericType,
        final Annotation[] annotations,
        final MediaType mediaType,
        final MultivaluedMap<String, Object> httpHeaders,
        final OutputStream entityStream)
                throws IOException, WebApplicationException {

    entityStream.write(String.format("(widget %s %s)", widget.getId(), widget.getValue()).getBytes(StandardCharsets.UTF_8));
}
 

/**
 * Copy the contents of the given InputStream to the given OutputStream.
 * Leaves both streams open when done.
 * 
 * @param in
 *            the InputStream to copy from
 * @param out
 *            the OutputStream to copy to
 * @return the number of bytes copied
 * @throws IOException
 *             in case of I/O errors
 */
public static int copy(InputStream in, OutputStream out) throws IOException {
	Assert.notNull(in, "No InputStream specified");
	Assert.notNull(out, "No OutputStream specified");
	int byteCount = 0;
	byte[] buffer = new byte[BUFFER_SIZE];
	int bytesRead = -1;
	while ((bytesRead = in.read(buffer)) != -1) {
		out.write(buffer, 0, bytesRead);
		byteCount += bytesRead;
	}
	out.flush();
	return byteCount;
}
 

@Test
public void testWrite() throws Exception {
    final TransferStatus status = new TransferStatus();
    final int length = 1048576;
    final byte[] content = RandomUtils.nextBytes(length);
    status.setLength(content.length);
    final Path home = new DefaultHomeFinderService(session).find();
    final Path vault = new Path(home, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.directory));
    final Path test = new Path(vault, new AlphanumericRandomStringService().random(), EnumSet.of(Path.Type.file));
    final CryptoVault cryptomator = new CryptoVault(vault, new DisabledPasswordStore());
    cryptomator.create(session, null, new VaultCredentials("test"));
    session.withRegistry(new DefaultVaultRegistry(new DisabledPasswordStore(), new DisabledPasswordCallback(), cryptomator));
    final CryptoWriteFeature<String> writer = new CryptoWriteFeature<String>(session, new DropboxWriteFeature(session), cryptomator);
    final Cryptor cryptor = cryptomator.getCryptor();
    final FileHeader header = cryptor.fileHeaderCryptor().create();
    status.setHeader(cryptor.fileHeaderCryptor().encryptHeader(header));
    status.setNonces(new RotatingNonceGenerator(cryptomator.numberOfChunks(content.length)));
    status.setChecksum(writer.checksum(test).compute(new ByteArrayInputStream(content), status));
    final OutputStream out = writer.write(test, status, new DisabledConnectionCallback());
    assertNotNull(out);
    new StreamCopier(status, status).transfer(new ByteArrayInputStream(content), out);
    out.close();
    assertTrue(new CryptoFindFeature(session, new DropboxFindFeature(session), cryptomator).find(test));
    assertEquals(content.length, new CryptoListService(session, session, cryptomator).list(test.getParent(), new DisabledListProgressListener()).get(test).attributes().getSize());
    assertEquals(content.length, new CryptoWriteFeature<>(session, new DropboxWriteFeature(session, new DefaultFindFeature(session), new DefaultAttributesFinderFeature(session), 150000000L), cryptomator).append(test, status.getLength(), PathCache.empty()).size, 0L);
    assertEquals(content.length, new CryptoWriteFeature<>(session, new DropboxWriteFeature(session, new DropboxFindFeature(session), new DropboxAttributesFinderFeature(session), 150000000L), cryptomator).append(test, status.getLength(), PathCache.empty()).size, 0L);
    final ByteArrayOutputStream buffer = new ByteArrayOutputStream(content.length);
    final InputStream in = new CryptoReadFeature(session, new DropboxReadFeature(session), cryptomator).read(test, new TransferStatus().length(content.length), new DisabledConnectionCallback());
    new StreamCopier(status, status).transfer(in, buffer);
    assertArrayEquals(content, buffer.toByteArray());
    new CryptoDeleteFeature(session, new DropboxDeleteFeature(session), cryptomator).delete(Arrays.asList(test, vault), new DisabledLoginCallback(), new Delete.DisabledCallback());
}
 

/**
 * outputStream转string按编码
 *
 * @param out         输出流
 * @param charsetName 编码格式
 * @return 字符串
 */
public static String outputStream2String(OutputStream out, String charsetName) {
    if (out == null || StringUtils.isSpace(charsetName)) return null;
    try {
        return new String(outputStream2Bytes(out), charsetName);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
        return null;
    }
}
 

@Override
public void write(OutputStream s) throws IOException
{
    try {
        s.write(data);
    }
    catch (IOException e) {
        Logger.getLogger(ByteArrayOutputRepresentation.class.getCanonicalName()).fine("Caught OutputRepresentation:IOException: " + e.getMessage());
    }
}
 

public void save() {
    try {
        OutputStream os = new BufferedOutputStream(mContext.openFileOutput(FILE_NAME, 0), 8192);
        DataOutputStream out = new DataOutputStream(os);
        out.writeInt(LAST_VERSION);
        out.writeInt(mDeleteMode);
        out.writeInt(mMode == null ? Base.DECIMAL.getQuickSerializable() : mMode.getQuickSerializable());
        mHistory.write(out);
        out.close();
    } catch (IOException e) {
        Log.e(TAG, "Cannot save to disc", e);
    }
}
 

/**
 * Repair a store by rolling back to the newest good version.
 *
 * @param fileName the file name
 */
private static void repair(String fileName, PrintWriter pw) {
    long version = Long.MAX_VALUE;
    OutputStream ignore = new OutputStream() {
        @Override
        public void write(int b) throws IOException {
            // ignore
        }
    };
    while (version >= 0) {
        pw.println(version == Long.MAX_VALUE ? "Trying latest version" : ("Trying version " + version));
        pw.flush();
        version = rollback(fileName, version, new PrintWriter(ignore));
        try {
            String error = info(fileName + ".temp", new PrintWriter(ignore));
            if (error == null) {
                FilePath.get(fileName).moveTo(FilePath.get(fileName + ".back"), true);
                FilePath.get(fileName + ".temp").moveTo(FilePath.get(fileName), true);
                pw.println("Success");
                break;
            }
            pw.println("    ... failed: " + error);
        } catch (Exception e) {
            pw.println("Fail: " + e.getMessage());
            pw.flush();
        }
        version--;
    }
    pw.flush();
}
 

/**
 * Encode the byte data to base 64 writing it to the given output stream.
 *
 * @return the number of bytes produced.
 */
public static int encode(
    byte[]                data,
    OutputStream    out)
    throws IOException
{
    return encoder.encode(data, 0, data.length, out);
}
 

@Override
public void save(@NonNull final OutputStream _outputStream,
                 @NonNull final Object _object,
                 @NonNull final List<Class<?>> _asStringClasses) {
    try {
        log.debug("Saving json");

        mapper.writerWithDefaultPrettyPrinter().writeValue(_outputStream, _object);
    } catch (IOException _e) {
        log.error("Error saving JSON", _e);
    }
}
 

@Test
public void hasImpl()
{
   Assert.assertTrue(impls.hasImpl(File.class));
   Assert.assertTrue(impls.hasImpl(InputStream.class));
   Assert.assertTrue(impls.hasImpl(DrbNode.class));
   Assert.assertTrue(impls.hasImpl(URL.class));
   Assert.assertTrue(impls.hasImpl(DrbItem.class));

   Assert.assertFalse(impls.hasImpl(DrbNodeSpi.class));
   Assert.assertFalse(impls.hasImpl(OutputStream.class));
}
 

private void pipe(final InputStream in, final OutputStream out)
		throws IOException {
	lastReadTime = System.currentTimeMillis();
	final byte[] buf = new byte[BUF_SIZE];
	int len = 0;
	while (len >= 0) {
		try {
			if (len != 0) {
				out.write(buf, 0, len);
				out.flush();
			}
			len = in.read(buf);
			lastReadTime = System.currentTimeMillis();
		} catch (final InterruptedIOException iioe) {
			if (iddleTimeout == 0) {
				return;// Other thread interrupted us.
			}
			final long timeSinceRead = System.currentTimeMillis()
					- lastReadTime;

			if (timeSinceRead >= iddleTimeout - 1000) {
				return;
			}
			len = 0;

		}
	}
}
 

public void buildExcel(HttpServletRequest req, HttpServletResponse resp,boolean withPage,boolean withSheet) throws IOException {
	String file=req.getParameter("_u");
	file=decode(file);
	if(StringUtils.isBlank(file)){
		throw new ReportComputeException("Report file can not be null.");
	}
	String fileName=req.getParameter("_n");
	fileName=buildDownloadFileName(file, fileName, ".xlsx");
	resp.setContentType("application/octet-stream;charset=ISO8859-1");
	fileName=new String(fileName.getBytes("UTF-8"),"ISO8859-1");
	resp.setHeader("Content-Disposition","attachment;filename=\"" + fileName + "\"");
	Map<String, Object> parameters = buildParameters(req);
	OutputStream outputStream=resp.getOutputStream();
	if(file.equals(PREVIEW_KEY)){
		ReportDefinition reportDefinition=(ReportDefinition)TempObjectCache.getObject(PREVIEW_KEY);
		if(reportDefinition==null){
			throw new ReportDesignException("Report data has expired,can not do export excel.");
		}
		Report report=reportBuilder.buildReport(reportDefinition, parameters);	
		if(withPage){
			excelProducer.produceWithPaging(report, outputStream);
		}else if(withSheet){
			excelProducer.produceWithSheet(report, outputStream);
		}else{
			excelProducer.produce(report, outputStream);				
		}
	}else{
		ExportConfigure configure=new ExportConfigureImpl(file,parameters,outputStream);
		if(withPage){
			exportManager.exportExcelWithPaging(configure);
		}else if(withSheet){
			exportManager.exportExcelWithPagingSheet(configure);
		}else{
			exportManager.exportExcel(configure);
		}
	}
	outputStream.flush();
	outputStream.close();
}
 

@Override
public void writeTo(final OutputStream outstream) throws IOException {
    Args.notNull(outstream, "Output stream");
    final InputStream instream = getContent();
    try {
        int l;
        final byte[] tmp = new byte[OUTPUT_BUFFER_SIZE];
        while ((l = instream.read(tmp)) != -1) {
            outstream.write(tmp, 0, l);
        }
    } finally {
        instream.close();
    }
}
 

public Data transform(Data data, XMLCryptoContext xc, OutputStream os)
    throws TransformException
{
    if (data == null) {
        throw new NullPointerException("data must not be null");
    }
    if (os == null) {
        throw new NullPointerException("output stream must not be null");
    }
    return transformIt(data, xc, os);
}
 

public static void writeToStream(BitMatrix matrix, String format, OutputStream stream)
  throws IOException {
  BufferedImage image = toBufferedImage(matrix);
  if (!ImageIO.write(image, format, stream)) {
    throw new IOException("Could not write an image of format " + format);
  }
}
 

@Override
@NonNull
public final OutputStream openOutputStream() throws IOException {
    final FileObject file = handle.resolveFileObject(true);
    if (file == null) {
        throw new IOException("Cannot create file: " + toString());   //NOI18N
    }
    OutputStream res = createOutputStream();
    if (res == null) {
        res = new LckStream (file);
    }
    return res;
}
 

void encryptData(WrapToken token, byte[] confounder, byte[] plaintext,
    int start, int len, byte[] padding, OutputStream os)
    throws GSSException, IOException {

    switch (sealAlg) {
    case MessageToken.SEAL_ALG_DES:
        // Encrypt on the fly and write
        Cipher des = getInitializedDes(true, getDesEncryptionKey(keybytes),
            ZERO_IV);
        CipherOutputStream cos = new CipherOutputStream(os, des);
        // debug(getHexBytes(confounder, confounder.length));
        cos.write(confounder);
        // debug(" " + getHexBytes(plaintext, start, len));
        cos.write(plaintext, start, len);
        // debug(" " + getHexBytes(padding, padding.length));
        cos.write(padding);
        break;

    case MessageToken.SEAL_ALG_DES3_KD:
        byte[] ctext = des3KdEncrypt(confounder, plaintext, start, len,
            padding);

        // Write to stream
        os.write(ctext);
        break;

    case MessageToken.SEAL_ALG_ARCFOUR_HMAC:
        byte[] ciphertext = arcFourEncrypt(token, confounder, plaintext,
            start, len, padding);

        // Write to stream
        os.write(ciphertext);
        break;

    default:
        throw new GSSException(GSSException.FAILURE, -1,
            "Unsupported seal algorithm: " + sealAlg);
    }
}
 

public static void int64ToByteStreamLE(long val, OutputStream stream) throws IOException {
    stream.write((int) (0xFF & val));
    stream.write((int) (0xFF & (val >> 8)));
    stream.write((int) (0xFF & (val >> 16)));
    stream.write((int) (0xFF & (val >> 24)));
    stream.write((int) (0xFF & (val >> 32)));
    stream.write((int) (0xFF & (val >> 40)));
    stream.write((int) (0xFF & (val >> 48)));
    stream.write((int) (0xFF & (val >> 56)));
}
 

@Test
public void buildOpportunisticEncrypt__withNoKeysAndNoSignOnly__shouldNotBeSigned() throws MessagingException {
    ComposeCryptoStatus cryptoStatus = cryptoStatusBuilder
            .setRecipients(Collections.singletonList(new Recipient("test", "[email protected]", "labru", -1, "key")))
            .setCryptoMode(CryptoMode.NO_CHOICE)
            .build();
    pgpMessageBuilder.setCryptoStatus(cryptoStatus);


    Intent returnIntent = new Intent();
    returnIntent.putExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR);
    returnIntent.putExtra(OpenPgpApi.RESULT_ERROR,
            new OpenPgpError(OpenPgpError.OPPORTUNISTIC_MISSING_KEYS, "Missing keys"));


    when(openPgpApi.executeApi(any(Intent.class), any(OpenPgpDataSource.class), any(OutputStream.class)))
            .thenReturn(returnIntent);

    Callback mockCallback = mock(Callback.class);
    pgpMessageBuilder.buildAsync(mockCallback);


    ArgumentCaptor<MimeMessage> captor = ArgumentCaptor.forClass(MimeMessage.class);
    verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false));
    verifyNoMoreInteractions(mockCallback);

    MimeMessage message = captor.getValue();
    Assert.assertEquals("text/plain", message.getMimeType());
}
 

@Override
public void writeTo(PropertyBox t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
		MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream)
		throws IOException, WebApplicationException {
	try (final Writer writer = new OutputStreamWriter(entityStream, CHARSET)) {
		try {
			getObjectWriter().writeValue(writer, t);
		} catch (JsonProcessingException e) {
			throw new WebApplicationException(e.getMessage(), e, Status.BAD_REQUEST);
		}
	}
}
 

@Override
public void write(TupleQueryResult tupleQueryResult, OutputStream outputStream)
    throws IOException {
  JsonGenerator jsonGenerator = createFactory().createGenerator(outputStream);

  createSerializer().serialize(tupleQueryResult, jsonGenerator, null);

  jsonGenerator.close();
}
 

private static void write(
    OutputStream out, byte[] b, int off, int len, boolean singleByte)
    throws IOException {
  if (singleByte) {
    for (int i = off; i < off + len; i++) {
      out.write(b[i]);
    }
  } else {
    out.write(b, off, len);
  }
  out.flush(); // for coverage
}
 

private static void copyStream(InputStream is, OutputStream os)
    throws IOException
{
    byte[] copyBuf = new byte[8192];
    int n;
    while ((n = is.read(copyBuf)) != -1) {
        os.write(copyBuf, 0, n);
    }
}
 

@Override
public OutputStream start() throws IOException {
    assert null == this.cout;
    assert null == this.dout;
    OutputStream out = this.method.start();
    final long size = this.entry.getSize();
    final int blockSize = UNKNOWN != size
            ? BZip2CompressorOutputStream.chooseBlockSize(size)
            : getBZip2BlockSize();
    out = this.cout = new BZip2CompressorOutputStream(out, blockSize);
    return this.dout = new LittleEndianOutputStream(out);
}
 

public static void writeFile(File file, byte[] data) throws IOException {
  OutputStream out = new FileOutputStream(file);
  try {
    out.write(data);
    out.flush();
    out.close();
  } finally {
    try {
      out.close();
    } catch (IOException ex) {
      // Do nothing.
    }
  }
}
 

@Override
public OutputStream getContentOutputStream() throws ContentIOException
{
    return this.cacheWriter.getContentOutputStream();
}
 

@Override
public void setOutputStream(OutputStream outputStream) {
	this.outputStream = outputStream;
}
 

@Override
public void writeValue(OutputStream out,
    Object value) throws IOException, JsonGenerationException, JsonMappingException {
  Object[] values = (Object[]) value;
  super.writeValue(out, values[0]);
}
 

public FilterOut(OutputStream out) {
  super(out);
}
 

@Override
public void store(BuildCacheKey key, final BuildCacheEntryWriter output) throws BuildCacheException {
    final URI uri = root.resolve(key.getHashCode());
    HttpPut httpPut = new HttpPut(uri);
    httpPut.setEntity(new AbstractHttpEntity() {
        @Override
        public boolean isRepeatable() {
            return true;
        }

        @Override
        public long getContentLength() {
            return -1;
        }

        @Override
        public InputStream getContent() throws IOException, UnsupportedOperationException {
            throw new UnsupportedOperationException();
        }

        @Override
        public void writeTo(OutputStream outstream) throws IOException {
            output.writeTo(outstream);
        }

        @Override
        public boolean isStreaming() {
            return false;
        }
    });
    CloseableHttpResponse response = null;
    try {
        response = httpClient.execute(httpPut);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Response for PUT {}: {}", safeUri(uri), response.getStatusLine());
        }
        // TODO: We should examine the status to make sure the PUT was successful
    } catch (IOException e) {
        // TODO: We should consider different types of exceptions as fatal/recoverable.
        // Right now, everything is considered recoverable.
        throw new BuildCacheException(String.format("storing key '%s' in %s", key, getDescription()), e);
    } finally {
        HttpClientUtils.closeQuietly(response);
    }
}
 

private void writeNewLine(OutputStream os) throws IOException {
	os.write('\r');
	os.write('\n');
}
 

/**
 * handle Method
 * Handle the Http Notification request from Mobius
 */
public void handle(HttpExchange t) throws IOException {
	System.out.println("[&CubeThyme] Receive a HTTP request");
	System.out.println("[&CubeThyme] HTTP Method : " + t.getRequestMethod());
	System.out.println("[&CubeThyme] HTTP Path   : " + t.getRequestURI().getPath());
	
	String requestBody = "";
	
	if (t.getRequestMethod().equals("POST")) {
		List<String> requestOriginator = t.getRequestHeaders().get("X-M2M-Origin");
		String origin = requestOriginator.get(0);
		System.out.println("[&CubeThyme] HTTP X-M2M-Origin : " + origin);
		
		requestBody = getStringFromInputStream(t.getRequestBody());
		System.out.println("[&CubeThyme] HTTP Request Body   : " + requestBody);
		
		ArrayList<String> contentString = new ArrayList<String>();
		String content = "";
		String subr = "";
		String container = "";
		
		try {
			contentString = HttpServerParser.notificationParse(requestBody);
			content = contentString.get(0);
			subr = contentString.get(1);
			
			String[] urlPath = subr.split("/");
			container = urlPath[urlPath.length-2];
			
			System.out.println("[&CubeThyme] HTTP Notification container : " + container);
			
			JSONObject contentObject = new JSONObject();
			try {
				contentObject.put("ctname", container);
				contentObject.put("con", content);
			} catch (JSONException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			
			TasSender.sendMessage(container, contentObject.toString());
			System.out.println("[&CubeThyme] HTTP Notification message   : " + content);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.out.println("[&CubeThyme] TAS connection is closed\n");
		}
	}
	
	String response = "";
	Headers responseHeaders = t.getResponseHeaders();
	responseHeaders.add("X-M2M-RSC", "2000");
	responseHeaders.add("X-M2M-RI", t.getRequestHeaders().get("X-M2M-RI").get(0));
	t.sendResponseHeaders(200, response.length());
	OutputStream os = t.getResponseBody();
	os.write(response.getBytes());
	os.close();
}
 

@Override
public RecordWriter createRecordWriter(OutputStream out) {
	return new RecordWriterImpl(out);
}
 

public DeviceGroupsOutputStream(OutputStream out) {
  super(out);
}
 

public void writeMainDexList(Closer closer, OutputStream out) throws IOException {
  InputStream input = getMainDexListOutput(closer);
  assert input != null;
  out.write(ByteStreams.toByteArray(input));
}