StreamDatabase.java
8.36 KB
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
/*
* Decompiled with CFR 0_118.
*/
package com.adobe.internal.io.stream;
import com.adobe.internal.io.ByteReader;
import com.adobe.internal.io.ByteWriter;
import com.adobe.internal.io.stream.InputByteStream;
import com.adobe.internal.io.stream.OutputByteStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
class StreamDatabase {
private Map inputStreamData = new HashMap();
private Map outputStreamData = new HashMap();
private ByteReader masterByteReader;
private boolean lenientMasterByteReader = false;
private boolean ignoreRemoveOnNonexistentReader = false;
private boolean ignoreRemoveOnNonexistentWriter = false;
StreamDatabase(ByteReader masterByteReader, boolean lenientMasterByteReader, boolean ignoreRemoveOnNonexistentReader, boolean ignoreRemoveOnNonexistentWriter) {
this.lenientMasterByteReader = lenientMasterByteReader;
this.ignoreRemoveOnNonexistentReader = ignoreRemoveOnNonexistentReader;
this.ignoreRemoveOnNonexistentWriter = ignoreRemoveOnNonexistentWriter;
this.initMasterByteReader(masterByteReader);
}
ByteReader resetMasterByteReader(ByteReader masterByteReader) throws IOException {
ByteReader oldMasterByteReader = this.masterByteReader;
StreamData oldBRData = (StreamData)this.inputStreamData.get(this.masterByteReader);
if (oldBRData != null && oldBRData.getReferences() != 0 && !this.lenientMasterByteReader) {
throw new RuntimeException("Closing master ByteReader with open streams.");
}
if (oldMasterByteReader != null) {
this.inputStreamData.remove(oldMasterByteReader);
try {
oldMasterByteReader.close();
}
catch (IOException e) {
IOException ioe = new IOException("Unable to close master ByteReader: " + oldMasterByteReader);
ioe.initCause(e);
throw ioe;
}
}
this.initMasterByteReader(masterByteReader);
return oldMasterByteReader;
}
private void initMasterByteReader(ByteReader masterByteReader) {
this.masterByteReader = masterByteReader;
if (this.masterByteReader != null) {
StreamData newBRData = new StreamData();
this.inputStreamData.put(this.masterByteReader, newBRData);
}
}
boolean addIBS(InputByteStream ibs, ByteReader br) {
boolean ibsFirstTime = false;
StreamData data = (StreamData)this.inputStreamData.get(br);
if (data == null) {
data = new StreamData();
this.inputStreamData.put(br, data);
ibsFirstTime = true;
}
data.addReference();
return ibsFirstTime;
}
boolean removeIBS(InputByteStream ibs, ByteReader br) {
boolean lastReference = true;
StreamData data = (StreamData)this.inputStreamData.get(br);
if (data == null) {
if (!this.ignoreRemoveOnNonexistentReader) {
throw new RuntimeException("Closing an InputByteStream that isn't in the stream database.");
}
} else {
lastReference = data.removeReference();
if (lastReference) {
this.inputStreamData.remove(br);
}
}
return lastReference;
}
boolean addOBS(OutputByteStream obs, ByteWriter bw) {
boolean obsFirstTime = false;
StreamData data = (StreamData)this.outputStreamData.get(bw);
if (data == null) {
data = new StreamData();
this.outputStreamData.put(bw, data);
obsFirstTime = true;
}
data.addReference();
return obsFirstTime;
}
boolean removeOBS(OutputByteStream obs, ByteWriter bw) {
boolean lastReference = true;
StreamData data = (StreamData)this.outputStreamData.get(bw);
if (data == null) {
if (!this.ignoreRemoveOnNonexistentWriter) {
throw new RuntimeException("Closing an OutputByteStream that isn't in the stream database.");
}
} else {
lastReference = data.removeReference();
if (lastReference) {
this.outputStreamData.remove(bw);
}
}
return lastReference & !this.inputStreamData.containsKey(bw);
}
boolean isOutputEmpty() {
return this.outputStreamData.isEmpty();
}
boolean isInputEmpty() {
return this.inputStreamData.isEmpty();
}
boolean isEmpty() {
return this.isInputEmpty() && this.isOutputEmpty();
}
int getOutputCount() {
return this.outputStreamData.size();
}
int getInputCount() {
return this.inputStreamData.size();
}
int getCount() {
return this.getOutputCount() + this.getInputCount();
}
public String toString() {
StreamData data;
StringBuilder buffer = new StringBuilder("Open ByteReader = ");
buffer.append(this.getInputCount()).append("\n").append("Open ByteWriter = ").append(this.getOutputCount()).append("\n").append("======== ByteReaders\n");
for (Object key2 : this.inputStreamData.keySet()) {
buffer.append("ByteReader = ").append(key2.toString()).append("\n");
data = (StreamData)this.inputStreamData.get(key2);
buffer.append(data.toString());
}
buffer.append("======== ByteWriters\n");
for (Object key2 : this.outputStreamData.keySet()) {
buffer.append("ByteWriter = ").append(key2.toString()).append("\n");
data = (StreamData)this.outputStreamData.get(key2);
buffer.append(data.toString());
}
return buffer.toString();
}
int closeAllOpen(boolean ignoreMaster) throws IOException {
int numberOpen = this.closeAllOpenReaders(ignoreMaster);
return numberOpen += this.closeAllOpenWriters(ignoreMaster);
}
private int closeAllOpenReaders(boolean ignoreMaster) throws IOException {
int numberOpen = 0;
Set openReaderSet = this.inputStreamData.keySet();
numberOpen += openReaderSet.size();
for (ByteReader openReader : openReaderSet) {
if (ignoreMaster && openReader == this.masterByteReader) continue;
try {
openReader.close();
continue;
}
catch (IOException e) {
IOException ioe = new IOException("Unable to close ByteReader: " + openReader);
ioe.initCause(e);
throw ioe;
}
}
this.inputStreamData.clear();
return numberOpen;
}
private int closeAllOpenWriters(boolean ignoreMaster) throws IOException {
int numberOpen = 0;
Set openWriterSet = this.outputStreamData.keySet();
numberOpen += openWriterSet.size();
for (ByteWriter openWriter : openWriterSet) {
if (ignoreMaster && openWriter == this.masterByteReader) continue;
try {
openWriter.close();
continue;
}
catch (IOException e) {
IOException ioe = new IOException("Unable to close ByteWriter: " + openWriter);
ioe.initCause(e);
throw ioe;
}
}
this.outputStreamData.clear();
return numberOpen;
}
private static class StreamData {
private long references;
private long maxReferences;
private String stackTrace;
public long getReferences() {
return this.references;
}
public long getMaxReferences() {
return this.maxReferences;
}
public void addReference() {
++this.references;
++this.maxReferences;
}
public boolean removeReference() {
--this.references;
if (this.references < 0) {
throw new RuntimeException("Stream closed and not removed from stream database.");
}
return this.references == 0;
}
public String toString() {
StringBuilder buffer = new StringBuilder("Number of open references = ");
buffer.append(this.getReferences()).append("\n").append("Number of max references = ").append(this.getMaxReferences()).append("\n").append("Originally created = \n").append(this.stackTrace).append("\n");
return buffer.toString();
}
}
}