blob: a3b2be67f77ff6ad5513637de843c6bd3e9f62ae (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
package org.eclipse.debug.internal.core;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import java.io.IOException;
import java.io.OutputStream;
import java.util.Vector;
import org.eclipse.debug.core.DebugPlugin;
/**
* Writes to the input stream of a system process,
* queueing output if the stream is blocked.
*
* The input stream monitor writes to system in via
* an output stream.
*/
public class InputStreamMonitor {
/**
* The stream which is being written to (connected to system in).
*/
private OutputStream fStream;
/**
* The queue of output.
*/
private Vector fQueue;
/**
* The thread which writes to the stream.
*/
private Thread fThread;
/**
* A lock for ensuring that writes to the queue are contiguous
*/
private Object fLock;
/**
* Creates an input stream monitor which writes
* to system in via the given output stream.
*/
public InputStreamMonitor(OutputStream stream) {
fStream= stream;
fQueue= new Vector();
fLock= new Object();
}
/**
* Appends the given text to the stream, or
* queues the text to be written at a later time
* if the stream is blocked.
*/
public void write(String text) {
synchronized(fLock) {
fQueue.add(text);
fLock.notifyAll();
}
}
/**
* Starts a thread which writes the stream.
*/
public void startMonitoring() {
if (fThread == null) {
fThread= new Thread(new Runnable() {
public void run() {
write();
}
}, DebugCoreMessages.getString("InputStreamMonitor.label")); //$NON-NLS-1$
fThread.start();
}
}
/**
* Close all communications between this
* monitor and the underlying stream.
*/
public void close() {
if (fThread != null) {
Thread thread= fThread;
fThread= null;
thread.interrupt();
}
}
/**
* Continuously writes to the stream.
*/
protected void write() {
while (fThread != null) {
writeNext();
}
try {
fStream.close();
} catch (IOException e) {
DebugPlugin.log(e);
}
}
/**
* Write the text in the queue to the stream.
*/
protected void writeNext() {
while (!fQueue.isEmpty()) {
String text = (String)fQueue.firstElement();
fQueue.removeElementAt(0);
try {
fStream.write(text.getBytes());
fStream.flush();
} catch (IOException e) {
DebugPlugin.log(e);
}
}
try {
synchronized(fLock) {
fLock.wait();
}
} catch (InterruptedException e) {
}
}
}
|
