001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package java.io;
019:
020: import org.apache.harmony.luni.util.Msg;
021:
022: /**
023: * FilteredOutputStream is a class which takes an output stream and
024: * <em>filters</em> the output in some way. The filtered view may be a
025: * buffered output or one which compresses data before actually writing the
026: * bytes. FilterOutputStreams are meant for byte streams.
027: *
028: * @see FilterInputStream
029: */
030: public class FilterOutputStream extends OutputStream {
031:
032: /**
033: * The target OutputStream for this filter.
034: */
035: protected OutputStream out;
036:
037: /**
038: * Constructs a new FilterOutputStream on the OutputStream <code>out</code>.
039: * All writes are now filtered through this stream.
040: *
041: * @param out
042: * the target OutputStream to filter writes on.
043: */
044: public FilterOutputStream(OutputStream out) {
045: this .out = out;
046: }
047:
048: /**
049: * Close this FilterOutputStream. This implementation closes the target
050: * stream.
051: *
052: * @throws IOException
053: * If an error occurs attempting to close this stream.
054: */
055: @Override
056: public void close() throws IOException {
057: try {
058: flush();
059: } catch (IOException e) {
060: // Ignored
061: }
062: /* Make sure we clean up this stream if exception fires */
063: out.close();
064: }
065:
066: /**
067: * Flush this FilterOutputStream to ensure all pending data is sent out to
068: * the target OutputStream. This implementation flushes the target
069: * OutputStream.
070: *
071: * @throws IOException
072: * If an error occurs attempting to flush this
073: * FilterOutputStream.
074: */
075: @Override
076: public void flush() throws IOException {
077: out.flush();
078: }
079:
080: /**
081: * Writes the entire contents of the byte array <code>buffer</code> to
082: * this FilterOutputStream. This implementation writes the
083: * <code>buffer</code> to the target stream.
084: *
085: * @param buffer
086: * the buffer to be written
087: *
088: * @throws IOException
089: * If an error occurs attempting to write to this
090: * FilterOutputStream.
091: */
092: @Override
093: public void write(byte buffer[]) throws IOException {
094: write(buffer, 0, buffer.length);
095: }
096:
097: /**
098: * Writes <code>count</code> <code>bytes</code> from the byte array
099: * <code>buffer</code> starting at <code>offset</code> to this
100: * FilterOutputStream. This implementation writes the <code>buffer</code>
101: * to the target OutputStream.
102: *
103: * @param buffer
104: * the buffer to be written
105: * @param offset
106: * offset in buffer to get bytes
107: * @param count
108: * number of bytes in buffer to write
109: *
110: * @throws IOException
111: * If an error occurs attempting to write to this
112: * FilterOutputStream.
113: * @throws IndexOutOfBoundsException
114: * If offset or count are outside of bounds.
115: */
116: @Override
117: public void write(byte buffer[], int offset, int count)
118: throws IOException {
119: // avoid int overflow, force null buffer check first
120: if (offset > buffer.length || offset < 0 || count < 0
121: || count > buffer.length - offset) {
122: throw new ArrayIndexOutOfBoundsException(Msg
123: .getString("K002f")); //$NON-NLS-1$
124: }
125: for (int i = 0; i < count; i++) {
126: // Call write() instead of out.write() since subclasses could
127: // override the write() method.
128: write(buffer[offset + i]);
129: }
130: }
131:
132: /**
133: * Writes the specified byte <code>oneByte</code> to this
134: * FilterOutputStream. Only the low order byte of <code>oneByte</code> is
135: * written. This implementation writes the byte to the target OutputStream.
136: *
137: * @param oneByte
138: * the byte to be written
139: *
140: * @throws IOException
141: * If an error occurs attempting to write to this
142: * FilterOutputStream.
143: */
144: @Override
145: public void write(int oneByte) throws IOException {
146: out.write(oneByte);
147: }
148: }
|