1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 package org.apache.commons.net.io;
19
20 import java.io.FilterOutputStream;
21 import java.io.IOException;
22 import java.io.OutputStream;
23
24 /***
25 * This class wraps an output stream, replacing all occurrences
26 * of <CR><LF> (carriage return followed by a linefeed),
27 * which is the NETASCII standard for representing a newline, with the
28 * local line separator representation. You would use this class to
29 * implement ASCII file transfers requiring conversion from NETASCII.
30 * <p>
31 * Because of the translation process, a call to <code>flush()</code> will
32 * not flush the last byte written if that byte was a carriage
33 * return. A call to {@link #close close() }, however, will
34 * flush the carriage return.
35 * <p>
36 * <p>
37 ***/
38
39 public final class FromNetASCIIOutputStream extends FilterOutputStream
40 {
41 private boolean __lastWasCR;
42
43 /***
44 * Creates a FromNetASCIIOutputStream instance that wraps an existing
45 * OutputStream.
46 * <p>
47 * @param output The OutputStream to wrap.
48 ***/
49 public FromNetASCIIOutputStream(OutputStream output)
50 {
51 super(output);
52 __lastWasCR = false;
53 }
54
55
56 private void __write(int ch) throws IOException
57 {
58 switch (ch)
59 {
60 case '\r':
61 __lastWasCR = true;
62 // Don't write anything. We need to see if next one is linefeed
63 break;
64 case '\n':
65 if (__lastWasCR)
66 {
67 out.write(FromNetASCIIInputStream._lineSeparatorBytes);
68 __lastWasCR = false;
69 break;
70 }
71 __lastWasCR = false;
72 out.write('\n');
73 break;
74 default:
75 if (__lastWasCR)
76 {
77 out.write('\r');
78 __lastWasCR = false;
79 }
80 out.write(ch);
81 break;
82 }
83 }
84
85
86 /***
87 * Writes a byte to the stream. Note that a call to this method
88 * might not actually write a byte to the underlying stream until a
89 * subsequent character is written, from which it can be determined if
90 * a NETASCII line separator was encountered.
91 * This is transparent to the programmer and is only mentioned for
92 * completeness.
93 * <p>
94 * @param ch The byte to write.
95 * @exception IOException If an error occurs while writing to the underlying
96 * stream.
97 ***/
98 @Override
99 public synchronized void write(int ch)
100 throws IOException
101 {
102 if (FromNetASCIIInputStream._noConversionRequired)
103 {
104 out.write(ch);
105 return ;
106 }
107
108 __write(ch);
109 }
110
111
112 /***
113 * Writes a byte array to the stream.
114 * <p>
115 * @param buffer The byte array to write.
116 * @exception IOException If an error occurs while writing to the underlying
117 * stream.
118 ***/
119 @Override
120 public synchronized void write(byte buffer[])
121 throws IOException
122 {
123 write(buffer, 0, buffer.length);
124 }
125
126
127 /***
128 * Writes a number of bytes from a byte array to the stream starting from
129 * a given offset.
130 * <p>
131 * @param buffer The byte array to write.
132 * @param offset The offset into the array at which to start copying data.
133 * @param length The number of bytes to write.
134 * @exception IOException If an error occurs while writing to the underlying
135 * stream.
136 ***/
137 @Override
138 public synchronized void write(byte buffer[], int offset, int length)
139 throws IOException
140 {
141 if (FromNetASCIIInputStream._noConversionRequired)
142 {
143 // FilterOutputStream method is very slow.
144 //super.write(buffer, offset, length);
145 out.write(buffer, offset, length);
146 return ;
147 }
148
149 while (length-- > 0) {
150 __write(buffer[offset++]);
151 }
152 }
153
154
155 /***
156 * Closes the stream, writing all pending data.
157 * <p>
158 * @exception IOException If an error occurs while closing the stream.
159 ***/
160 @Override
161 public synchronized void close()
162 throws IOException
163 {
164 if (FromNetASCIIInputStream._noConversionRequired)
165 {
166 super.close();
167 return ;
168 }
169
170 if (__lastWasCR) {
171 out.write('\r');
172 }
173 super.close();
174 }
175 }