All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.google.gwt.emul.java.io.OutputStream Maven / Gradle / Ivy

// CHECKSTYLE_OFF: Copyrighted to the Android Open Source Project.
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
// CHECKSTYLE_ON

package java.io;

import static javaemul.internal.InternalPreconditions.checkNotNull;

/**
 * A writable sink for bytes.
 *
 * 

Most clients will use output streams that write data to the file system * ({@link FileOutputStream}), the network ({@link java.net.Socket#getOutputStream()}/{@link * java.net.HttpURLConnection#getOutputStream()}), or to an in-memory byte array * ({@link ByteArrayOutputStream}). * *

Use {@link OutputStreamWriter} to adapt a byte stream like this one into a * character stream. * *

Most clients should wrap their output stream with {@link * BufferedOutputStream}. Callers that do only bulk writes may omit buffering. * *

Subclassing OutputStream

* Subclasses that decorate another output stream should consider subclassing * {@link FilterOutputStream}, which delegates all calls to the target output * stream. * *

All output stream subclasses should override both {@link * #write(int)} and {@link #write(byte[],int,int) write(byte[],int,int)}. The * three argument overload is necessary for bulk access to the data. This is * much more efficient than byte-by-byte access. * * @see InputStream * *

The implementation provided by this class behaves as described in the Java * API documentation except for {@link write(int)} which throws an exception of * type {@link java.lang.UnsupportedOperationException} instead of being * abstract. */ public abstract class OutputStream implements Closeable, Flushable { /** * Default constructor. */ public OutputStream() { } /** * Closes this stream. Implementations of this method should free any * resources used by the stream. This implementation does nothing. * * @throws IOException * if an error occurs while closing this stream. */ @Override public void close() throws IOException { /* empty */ } /** * Flushes this stream. Implementations of this method should ensure that * any buffered data is written out. This implementation does nothing. * * @throws IOException * if an error occurs while flushing this stream. */ @Override public void flush() throws IOException { /* empty */ } /** * Equivalent to {@code write(buffer, 0, buffer.length)}. */ public void write(byte[] buffer) throws IOException { // Note that GWT will throw a JavascriptException rather than a NullPointerException if we // skip this check and the buffer array is null. This way we ensure that this implementation // behaves in the same way as the classes that are emulated. checkNotNull(buffer); write(buffer, 0, buffer.length); } /** * Writes {@code count} bytes from the byte array {@code buffer} starting at * position {@code offset} to this stream. * * @param buffer * the buffer to be written. * @param offset * the start position in {@code buffer} from where to get bytes. * @param count * the number of bytes from {@code buffer} to write to this * stream. * @throws IOException * if an error occurs while writing to this stream. * @throws IndexOutOfBoundsException * if {@code offset < 0} or {@code count < 0}, or if * {@code offset + count} is bigger than the length of * {@code buffer}. */ public void write(byte[] buffer, int offset, int count) throws IOException { IOUtils.checkOffsetAndCount(buffer, offset, count); for (int i = offset; i < offset + count; i++) { write(buffer[i]); } } /** * Writes a single byte to this stream. Only the least significant byte of * the integer {@code oneByte} is written to the stream. * * @param oneByte * the byte to be written. * @throws IOException * if an error occurs while writing to this stream. */ public abstract void write(int oneByte) throws IOException; }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy