1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.mina.core.session;
21
22
23
24
25
26
27
28
29 public abstract class AbstractIoSessionConfig implements IoSessionConfig {
30
31 private int minReadBufferSize = 64;
32 private int readBufferSize = 2048;
33 private int maxReadBufferSize = 65536;
34 private int idleTimeForRead;
35 private int idleTimeForWrite;
36 private int idleTimeForBoth;
37 private int writeTimeout = 60;
38 private boolean useReadOperation;
39 private int throughputCalculationInterval = 3;
40
41 protected AbstractIoSessionConfig() {
42
43 }
44
45
46
47
48 public final void setAll(IoSessionConfig config) {
49 if (config == null) {
50 throw new NullPointerException("config");
51 }
52
53 setReadBufferSize(config.getReadBufferSize());
54 setMinReadBufferSize(config.getMinReadBufferSize());
55 setMaxReadBufferSize(config.getMaxReadBufferSize());
56 setIdleTime(IdleStatus.BOTH_IDLE, config.getIdleTime(IdleStatus.BOTH_IDLE));
57 setIdleTime(IdleStatus.READER_IDLE, config.getIdleTime(IdleStatus.READER_IDLE));
58 setIdleTime(IdleStatus.WRITER_IDLE, config.getIdleTime(IdleStatus.WRITER_IDLE));
59 setWriteTimeout(config.getWriteTimeout());
60 setUseReadOperation(config.isUseReadOperation());
61 setThroughputCalculationInterval(config.getThroughputCalculationInterval());
62
63 doSetAll(config);
64 }
65
66
67
68
69
70 protected abstract void doSetAll(IoSessionConfig config);
71
72
73
74
75 public int getReadBufferSize() {
76 return readBufferSize;
77 }
78
79
80
81
82 public void setReadBufferSize(int readBufferSize) {
83 if (readBufferSize <= 0) {
84 throw new IllegalArgumentException("readBufferSize: " + readBufferSize + " (expected: 1+)");
85 }
86 this.readBufferSize = readBufferSize;
87 }
88
89
90
91
92 public int getMinReadBufferSize() {
93 return minReadBufferSize;
94 }
95
96
97
98
99 public void setMinReadBufferSize(int minReadBufferSize) {
100 if (minReadBufferSize <= 0) {
101 throw new IllegalArgumentException("minReadBufferSize: " + minReadBufferSize + " (expected: 1+)");
102 }
103 if (minReadBufferSize > maxReadBufferSize ) {
104 throw new IllegalArgumentException("minReadBufferSize: " + minReadBufferSize + " (expected: smaller than " + maxReadBufferSize + ')');
105
106 }
107 this.minReadBufferSize = minReadBufferSize;
108 }
109
110
111
112
113 public int getMaxReadBufferSize() {
114 return maxReadBufferSize;
115 }
116
117
118
119
120 public void setMaxReadBufferSize(int maxReadBufferSize) {
121 if (maxReadBufferSize <= 0) {
122 throw new IllegalArgumentException("maxReadBufferSize: " + maxReadBufferSize + " (expected: 1+)");
123 }
124
125 if (maxReadBufferSize < minReadBufferSize) {
126 throw new IllegalArgumentException("maxReadBufferSize: " + maxReadBufferSize + " (expected: greater than " + minReadBufferSize + ')');
127
128 }
129 this.maxReadBufferSize = maxReadBufferSize;
130 }
131
132
133
134
135 public int getIdleTime(IdleStatus status) {
136 if (status == IdleStatus.BOTH_IDLE) {
137 return idleTimeForBoth;
138 }
139
140 if (status == IdleStatus.READER_IDLE) {
141 return idleTimeForRead;
142 }
143
144 if (status == IdleStatus.WRITER_IDLE) {
145 return idleTimeForWrite;
146 }
147
148 throw new IllegalArgumentException("Unknown idle status: " + status);
149 }
150
151
152
153
154 public long getIdleTimeInMillis(IdleStatus status) {
155 return getIdleTime(status) * 1000L;
156 }
157
158
159
160
161 public void setIdleTime(IdleStatus status, int idleTime) {
162 if (idleTime < 0) {
163 throw new IllegalArgumentException("Illegal idle time: " + idleTime);
164 }
165
166 if (status == IdleStatus.BOTH_IDLE) {
167 idleTimeForBoth = idleTime;
168 } else if (status == IdleStatus.READER_IDLE) {
169 idleTimeForRead = idleTime;
170 } else if (status == IdleStatus.WRITER_IDLE) {
171 idleTimeForWrite = idleTime;
172 } else {
173 throw new IllegalArgumentException("Unknown idle status: " + status);
174 }
175 }
176
177
178
179
180 public final int getBothIdleTime() {
181 return getIdleTime(IdleStatus.BOTH_IDLE);
182 }
183
184
185
186
187 public final long getBothIdleTimeInMillis() {
188 return getIdleTimeInMillis(IdleStatus.BOTH_IDLE);
189 }
190
191
192
193
194 public final int getReaderIdleTime() {
195 return getIdleTime(IdleStatus.READER_IDLE);
196 }
197
198
199
200
201 public final long getReaderIdleTimeInMillis() {
202 return getIdleTimeInMillis(IdleStatus.READER_IDLE);
203 }
204
205
206
207
208 public final int getWriterIdleTime() {
209 return getIdleTime(IdleStatus.WRITER_IDLE);
210 }
211
212
213
214
215 public final long getWriterIdleTimeInMillis() {
216 return getIdleTimeInMillis(IdleStatus.WRITER_IDLE);
217 }
218
219
220
221
222 public void setBothIdleTime(int idleTime) {
223 setIdleTime(IdleStatus.BOTH_IDLE, idleTime);
224 }
225
226
227
228
229 public void setReaderIdleTime(int idleTime) {
230 setIdleTime(IdleStatus.READER_IDLE, idleTime);
231 }
232
233
234
235
236 public void setWriterIdleTime(int idleTime) {
237 setIdleTime(IdleStatus.WRITER_IDLE, idleTime);
238 }
239
240
241
242
243 public int getWriteTimeout() {
244 return writeTimeout;
245 }
246
247
248
249
250 public long getWriteTimeoutInMillis() {
251 return writeTimeout * 1000L;
252 }
253
254
255
256
257 public void setWriteTimeout(int writeTimeout) {
258 if (writeTimeout < 0) {
259 throw new IllegalArgumentException("Illegal write timeout: "
260 + writeTimeout);
261 }
262 this.writeTimeout = writeTimeout;
263 }
264
265
266
267
268 public boolean isUseReadOperation() {
269 return useReadOperation;
270 }
271
272
273
274
275 public void setUseReadOperation(boolean useReadOperation) {
276 this.useReadOperation = useReadOperation;
277 }
278
279
280
281
282 public int getThroughputCalculationInterval() {
283 return throughputCalculationInterval;
284 }
285
286
287
288
289 public void setThroughputCalculationInterval(int throughputCalculationInterval) {
290 if (throughputCalculationInterval < 0) {
291 throw new IllegalArgumentException(
292 "throughputCalculationInterval: " + throughputCalculationInterval);
293 }
294
295 this.throughputCalculationInterval = throughputCalculationInterval;
296 }
297
298
299
300
301 public long getThroughputCalculationIntervalInMillis() {
302 return throughputCalculationInterval * 1000L;
303 }
304 }