001: /*
002: * Copyright (c) 1998-2008 Caucho Technology -- all rights reserved
003: *
004: * This file is part of Resin(R) Open Source
005: *
006: * Each copy or derived work must preserve the copyright notice and this
007: * notice unmodified.
008: *
009: * Resin Open Source is free software; you can redistribute it and/or modify
010: * it under the terms of the GNU General Public License as published by
011: * the Free Software Foundation; either version 2 of the License, or
012: * (at your option) any later version.
013: *
014: * Resin Open Source is distributed in the hope that it will be useful,
015: * but WITHOUT ANY WARRANTY; without even the implied warranty of
016: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
017: * of NON-INFRINGEMENT. See the GNU General Public License for more
018: * details.
019: *
020: * You should have received a copy of the GNU General Public License
021: * along with Resin Open Source; if not, write to the
022: *
023: * Free Software Foundation, Inc.
024: * 59 Temple Place, Suite 330
025: * Boston, MA 02111-1307 USA
026: *
027: * @author Scott Ferguson
028: */
029:
030: package com.caucho.quercus.resources;
031:
032: import com.caucho.quercus.QuercusException;
033: import com.caucho.quercus.env.Env;
034: import com.caucho.quercus.env.EnvCleanup;
035: import com.caucho.quercus.env.StringValue;
036: import com.caucho.quercus.env.UnicodeValueImpl;
037: import com.caucho.vfs.ReadStream;
038: import com.caucho.vfs.WriteStream;
039:
040: import java.io.IOException;
041:
042: /**
043: * Represents read/write stream
044: */
045: public class StreamReadWrite extends StreamResource implements
046: EnvCleanup {
047: private Env _env;
048: private ReadStream _is;
049: private WriteStream _os;
050:
051: public StreamReadWrite(Env env) {
052: _env = env;
053:
054: _env.addCleanup(this );
055: }
056:
057: public StreamReadWrite(Env env, ReadStream is, WriteStream os) {
058: this (env);
059:
060: init(is, os);
061: }
062:
063: protected void init(ReadStream is, WriteStream os) {
064: _is = is;
065: _os = os;
066: }
067:
068: /**
069: * Reads the next byte, returning -1 on eof.
070: */
071: public int read() throws IOException {
072: if (_is != null)
073: return _is.read();
074: else
075: return -1;
076: }
077:
078: /**
079: * Reads a buffer, returning -1 on eof.
080: */
081: public int read(byte[] buffer, int offset, int length)
082: throws IOException {
083: if (_is != null)
084: return _is.read(buffer, offset, length);
085: else
086: return -1;
087: }
088:
089: /**
090: * Reads the optional linefeed character from a \r\n
091: */
092: public boolean readOptionalLinefeed() throws IOException {
093: if (_is != null) {
094: int ch = _is.read();
095:
096: if (ch == '\n') {
097: return true;
098: } else {
099: _is.unread();
100: return false;
101: }
102: } else
103: return false;
104: }
105:
106: /**
107: * Reads a line from the buffer.
108: */
109: public StringValue readLine() throws IOException {
110: if (_is != null)
111: return _env.createString(_is.readLineNoChop());
112: else
113: return _env.createEmptyString();
114: }
115:
116: /**
117: * Reads a line from the stream into a buffer.
118: */
119: public int readLine(char[] buffer) {
120: try {
121: if (_is != null)
122: return _is.readLine(buffer, buffer.length, false);
123: else
124: return -1;
125: } catch (IOException e) {
126: return -1;
127: }
128: }
129:
130: /**
131: * Writes to a buffer.
132: */
133: public int write(byte[] buffer, int offset, int length)
134: throws IOException {
135: if (_os != null) {
136: _os.write(buffer, offset, length);
137:
138: return length;
139: } else {
140: return -1;
141: }
142: }
143:
144: /**
145: * prints
146: */
147: public void print(char ch) throws IOException {
148: print(String.valueOf(ch));
149: }
150:
151: /**
152: * prints
153: */
154: public void print(String s) throws IOException {
155: if (_os != null)
156: _os.print(s);
157: }
158:
159: /**
160: * Returns true on the end of file.
161: */
162: public boolean isEOF() {
163: return true;
164: }
165:
166: /**
167: * Flushes the output
168: */
169: public void flush() {
170: try {
171: if (_os != null)
172: _os.flush();
173: } catch (IOException e) {
174: throw new QuercusException(e);
175: }
176: }
177:
178: /**
179: * Returns the current location in the file.
180: */
181: public long getPosition() {
182: return 0;
183: }
184:
185: /**
186: * Closes the stream for reading.
187: */
188: public void closeRead() {
189: ReadStream is = _is;
190: _is = null;
191:
192: if (is != null)
193: is.close();
194: }
195:
196: /**
197: * Closes the stream for writing
198: */
199: public void closeWrite() {
200: WriteStream os = _os;
201: _os = null;
202:
203: try {
204: if (os != null)
205: os.close();
206: } catch (IOException e) {
207: }
208: }
209:
210: /**
211: * Closes the stream.
212: */
213: public void close() {
214: _env.removeCleanup(this );
215:
216: cleanup();
217: }
218:
219: /**
220: * Implements the EnvCleanup interface.
221: */
222: public void cleanup() {
223: ReadStream is = _is;
224: _is = null;
225:
226: WriteStream os = _os;
227: _os = null;
228:
229: if (is != null)
230: is.close();
231:
232: try {
233: if (os != null)
234: os.close();
235: } catch (IOException e) {
236: }
237: }
238:
239: }
|