1 /*
2 * Copyright 2012 The Netty Project
3 *
4 * The Netty Project licenses this file to you under the Apache License,
5 * version 2.0 (the "License"); you may not use this file except in compliance
6 * with the License. You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
14 * under the License.
15 */
16 package org.jboss.netty.handler.codec.replay;
17
18 import java.io.IOException;
19 import java.io.InputStream;
20 import java.io.OutputStream;
21 import java.nio.ByteBuffer;
22 import java.nio.ByteOrder;
23 import java.nio.channels.GatheringByteChannel;
24 import java.nio.channels.ScatteringByteChannel;
25 import java.nio.charset.Charset;
26
27 import org.jboss.netty.buffer.ChannelBuffer;
28 import org.jboss.netty.buffer.ChannelBufferFactory;
29 import org.jboss.netty.buffer.ChannelBufferIndexFinder;
30
31 class ReplayingDecoderBuffer implements ChannelBuffer {
32
33 private static final Error REPLAY = new ReplayError();
34
35 private final ReplayingDecoder<?> parent;
36 private boolean terminated;
37
38 ReplayingDecoderBuffer(ReplayingDecoder<?> parent) {
39 this.parent = parent;
40 }
41
42 private ChannelBuffer buf() {
43 return parent.internalBuffer();
44 }
45
46 void terminate() {
47 terminated = true;
48 }
49
50 public int capacity() {
51 if (terminated) {
52 return buf().capacity();
53 } else {
54 return Integer.MAX_VALUE;
55 }
56 }
57
58 public boolean isDirect() {
59 return buf().isDirect();
60 }
61
62 public boolean hasArray() {
63 return false;
64 }
65
66 public byte[] array() {
67 throw new UnsupportedOperationException();
68 }
69
70 public int arrayOffset() {
71 throw new UnsupportedOperationException();
72 }
73
74 public void clear() {
75 throw new UnreplayableOperationException();
76 }
77
78 @Override
79 public boolean equals(Object obj) {
80 return this == obj;
81 }
82
83 public int compareTo(ChannelBuffer buffer) {
84 throw new UnreplayableOperationException();
85 }
86
87 public ChannelBuffer copy() {
88 throw new UnreplayableOperationException();
89 }
90
91 public ChannelBuffer copy(int index, int length) {
92 checkIndex(index, length);
93 return buf().copy(index, length);
94 }
95
96 public void discardReadBytes() {
97 throw new UnreplayableOperationException();
98 }
99
100 public void ensureWritableBytes(int writableBytes) {
101 throw new UnreplayableOperationException();
102 }
103
104 public ChannelBuffer duplicate() {
105 throw new UnreplayableOperationException();
106 }
107
108 public byte getByte(int index) {
109 checkIndex(index, 1);
110 return buf().getByte(index);
111 }
112
113 public short getUnsignedByte(int index) {
114 checkIndex(index, 1);
115 return buf().getUnsignedByte(index);
116 }
117
118 public void getBytes(int index, byte[] dst, int dstIndex, int length) {
119 checkIndex(index, length);
120 buf().getBytes(index, dst, dstIndex, length);
121 }
122
123 public void getBytes(int index, byte[] dst) {
124 checkIndex(index, dst.length);
125 buf().getBytes(index, dst);
126 }
127
128 public void getBytes(int index, ByteBuffer dst) {
129 throw new UnreplayableOperationException();
130 }
131
132 public void getBytes(int index, ChannelBuffer dst, int dstIndex, int length) {
133 checkIndex(index, length);
134 buf().getBytes(index, dst, dstIndex, length);
135 }
136
137 public void getBytes(int index, ChannelBuffer dst, int length) {
138 throw new UnreplayableOperationException();
139 }
140
141 public void getBytes(int index, ChannelBuffer dst) {
142 throw new UnreplayableOperationException();
143 }
144
145 public int getBytes(int index, GatheringByteChannel out, int length)
146 throws IOException {
147 throw new UnreplayableOperationException();
148 }
149
150 public void getBytes(int index, OutputStream out, int length)
151 throws IOException {
152 throw new UnreplayableOperationException();
153 }
154
155 public int getInt(int index) {
156 checkIndex(index, 4);
157 return buf().getInt(index);
158 }
159
160 public long getUnsignedInt(int index) {
161 checkIndex(index, 4);
162 return buf().getUnsignedInt(index);
163 }
164
165 public long getLong(int index) {
166 checkIndex(index, 8);
167 return buf().getLong(index);
168 }
169
170 public int getMedium(int index) {
171 checkIndex(index, 3);
172 return buf().getMedium(index);
173 }
174
175 public int getUnsignedMedium(int index) {
176 checkIndex(index, 3);
177 return buf().getUnsignedMedium(index);
178 }
179
180 public short getShort(int index) {
181 checkIndex(index, 2);
182 return buf().getShort(index);
183 }
184
185 public int getUnsignedShort(int index) {
186 checkIndex(index, 2);
187 return buf().getUnsignedShort(index);
188 }
189
190 public char getChar(int index) {
191 checkIndex(index, 2);
192 return buf().getChar(index);
193 }
194
195 public float getFloat(int index) {
196 checkIndex(index, 4);
197 return buf().getFloat(index);
198 }
199
200 public double getDouble(int index) {
201 checkIndex(index, 8);
202 return buf().getDouble(index);
203 }
204
205 @Override
206 public int hashCode() {
207 throw new UnreplayableOperationException();
208 }
209
210 public int indexOf(int fromIndex, int toIndex, byte value) {
211 int endIndex = buf().indexOf(fromIndex, toIndex, value);
212 if (endIndex < 0) {
213 throw REPLAY;
214 }
215 return endIndex;
216 }
217
218 public int indexOf(int fromIndex, int toIndex,
219 ChannelBufferIndexFinder indexFinder) {
220 int endIndex = buf().indexOf(fromIndex, toIndex, indexFinder);
221 if (endIndex < 0) {
222 throw REPLAY;
223 }
224 return endIndex;
225 }
226
227 public int bytesBefore(byte value) {
228 int bytes = buf().bytesBefore(value);
229 if (bytes < 0) {
230 throw REPLAY;
231 }
232 return bytes;
233 }
234
235 public int bytesBefore(ChannelBufferIndexFinder indexFinder) {
236 int bytes = buf().bytesBefore(indexFinder);
237 if (bytes < 0) {
238 throw REPLAY;
239 }
240 return bytes;
241 }
242
243 public int bytesBefore(int length, byte value) {
244 checkReadableBytes(length);
245 int bytes = buf().bytesBefore(length, value);
246 if (bytes < 0) {
247 throw REPLAY;
248 }
249 return bytes;
250 }
251
252 public int bytesBefore(int length, ChannelBufferIndexFinder indexFinder) {
253 checkReadableBytes(length);
254 int bytes = buf().bytesBefore(length, indexFinder);
255 if (bytes < 0) {
256 throw REPLAY;
257 }
258 return bytes;
259 }
260
261 public int bytesBefore(int index, int length, byte value) {
262 int bytes = buf().bytesBefore(index, length, value);
263 if (bytes < 0) {
264 throw REPLAY;
265 }
266 return bytes;
267 }
268
269 public int bytesBefore(int index, int length,
270 ChannelBufferIndexFinder indexFinder) {
271 int bytes = buf().bytesBefore(index, length, indexFinder);
272 if (bytes < 0) {
273 throw REPLAY;
274 }
275 return bytes;
276 }
277
278 public void markReaderIndex() {
279 buf().markReaderIndex();
280 }
281
282 public void markWriterIndex() {
283 throw new UnreplayableOperationException();
284 }
285
286 public ChannelBufferFactory factory() {
287 return buf().factory();
288 }
289
290 public ByteOrder order() {
291 return buf().order();
292 }
293
294 public boolean readable() {
295 return terminated? buf().readable() : true;
296 }
297
298 public int readableBytes() {
299 if (terminated) {
300 return buf().readableBytes();
301 } else {
302 return Integer.MAX_VALUE - buf().readerIndex();
303 }
304 }
305
306 public byte readByte() {
307 checkReadableBytes(1);
308 return buf().readByte();
309 }
310
311 public short readUnsignedByte() {
312 checkReadableBytes(1);
313 return buf().readUnsignedByte();
314 }
315
316 public void readBytes(byte[] dst, int dstIndex, int length) {
317 checkReadableBytes(length);
318 buf().readBytes(dst, dstIndex, length);
319 }
320
321 public void readBytes(byte[] dst) {
322 checkReadableBytes(dst.length);
323 buf().readBytes(dst);
324 }
325
326 public void readBytes(ByteBuffer dst) {
327 throw new UnreplayableOperationException();
328 }
329
330 public void readBytes(ChannelBuffer dst, int dstIndex, int length) {
331 checkReadableBytes(length);
332 buf().readBytes(dst, dstIndex, length);
333 }
334
335 public void readBytes(ChannelBuffer dst, int length) {
336 throw new UnreplayableOperationException();
337 }
338
339 public void readBytes(ChannelBuffer dst) {
340 throw new UnreplayableOperationException();
341 }
342
343 public int readBytes(GatheringByteChannel out, int length)
344 throws IOException {
345 throw new UnreplayableOperationException();
346 }
347
348 public ChannelBuffer readBytes(int length) {
349 checkReadableBytes(length);
350 return buf().readBytes(length);
351 }
352
353 public ChannelBuffer readSlice(int length) {
354 checkReadableBytes(length);
355 return buf().readSlice(length);
356 }
357
358 public void readBytes(OutputStream out, int length) throws IOException {
359 throw new UnreplayableOperationException();
360 }
361
362 public int readerIndex() {
363 return buf().readerIndex();
364 }
365
366 public void readerIndex(int readerIndex) {
367 buf().readerIndex(readerIndex);
368 }
369
370 public int readInt() {
371 checkReadableBytes(4);
372 return buf().readInt();
373 }
374
375 public long readUnsignedInt() {
376 checkReadableBytes(4);
377 return buf().readUnsignedInt();
378 }
379
380 public long readLong() {
381 checkReadableBytes(8);
382 return buf().readLong();
383 }
384
385 public int readMedium() {
386 checkReadableBytes(3);
387 return buf().readMedium();
388 }
389
390 public int readUnsignedMedium() {
391 checkReadableBytes(3);
392 return buf().readUnsignedMedium();
393 }
394
395 public short readShort() {
396 checkReadableBytes(2);
397 return buf().readShort();
398 }
399
400 public int readUnsignedShort() {
401 checkReadableBytes(2);
402 return buf().readUnsignedShort();
403 }
404
405 public char readChar() {
406 checkReadableBytes(2);
407 return buf().readChar();
408 }
409
410 public float readFloat() {
411 checkReadableBytes(4);
412 return buf().readFloat();
413 }
414
415 public double readDouble() {
416 checkReadableBytes(8);
417 return buf().readDouble();
418 }
419
420 public void resetReaderIndex() {
421 buf().resetReaderIndex();
422 }
423
424 public void resetWriterIndex() {
425 throw new UnreplayableOperationException();
426 }
427
428 public void setByte(int index, int value) {
429 throw new UnreplayableOperationException();
430 }
431
432 public void setBytes(int index, byte[] src, int srcIndex, int length) {
433 throw new UnreplayableOperationException();
434 }
435
436 public void setBytes(int index, byte[] src) {
437 throw new UnreplayableOperationException();
438 }
439
440 public void setBytes(int index, ByteBuffer src) {
441 throw new UnreplayableOperationException();
442 }
443
444 public void setBytes(int index, ChannelBuffer src, int srcIndex, int length) {
445 throw new UnreplayableOperationException();
446 }
447
448 public void setBytes(int index, ChannelBuffer src, int length) {
449 throw new UnreplayableOperationException();
450 }
451
452 public void setBytes(int index, ChannelBuffer src) {
453 throw new UnreplayableOperationException();
454 }
455
456 public int setBytes(int index, InputStream in, int length)
457 throws IOException {
458 throw new UnreplayableOperationException();
459 }
460
461 public void setZero(int index, int length) {
462 throw new UnreplayableOperationException();
463 }
464
465 public int setBytes(int index, ScatteringByteChannel in, int length)
466 throws IOException {
467 throw new UnreplayableOperationException();
468 }
469
470 public void setIndex(int readerIndex, int writerIndex) {
471 throw new UnreplayableOperationException();
472 }
473
474 public void setInt(int index, int value) {
475 throw new UnreplayableOperationException();
476 }
477
478 public void setLong(int index, long value) {
479 throw new UnreplayableOperationException();
480 }
481
482 public void setMedium(int index, int value) {
483 throw new UnreplayableOperationException();
484 }
485
486 public void setShort(int index, int value) {
487 throw new UnreplayableOperationException();
488 }
489
490 public void setChar(int index, int value) {
491 throw new UnreplayableOperationException();
492 }
493
494 public void setFloat(int index, float value) {
495 throw new UnreplayableOperationException();
496 }
497
498 public void setDouble(int index, double value) {
499 throw new UnreplayableOperationException();
500 }
501
502 public void skipBytes(int length) {
503 checkReadableBytes(length);
504 buf().skipBytes(length);
505 }
506
507 public ChannelBuffer slice() {
508 throw new UnreplayableOperationException();
509 }
510
511 public ChannelBuffer slice(int index, int length) {
512 checkIndex(index, length);
513 return buf().slice(index, length);
514 }
515
516 public ByteBuffer toByteBuffer() {
517 throw new UnreplayableOperationException();
518 }
519
520 public ByteBuffer toByteBuffer(int index, int length) {
521 checkIndex(index, length);
522 return buf().toByteBuffer(index, length);
523 }
524
525 public ByteBuffer[] toByteBuffers() {
526 throw new UnreplayableOperationException();
527 }
528
529 public ByteBuffer[] toByteBuffers(int index, int length) {
530 checkIndex(index, length);
531 return buf().toByteBuffers(index, length);
532 }
533
534 public String toString(int index, int length, Charset charset) {
535 checkIndex(index, length);
536 return buf().toString(index, length, charset);
537 }
538
539 public String toString(Charset charsetName) {
540 throw new UnreplayableOperationException();
541 }
542
543 @Override
544 public String toString() {
545 return getClass().getSimpleName() + '(' +
546 "ridx=" +
547 readerIndex() +
548 ", " +
549 "widx=" +
550 writerIndex() +
551 ')';
552 }
553
554 public boolean writable() {
555 return false;
556 }
557
558 public int writableBytes() {
559 return 0;
560 }
561
562 public void writeByte(int value) {
563 throw new UnreplayableOperationException();
564 }
565
566 public void writeBytes(byte[] src, int srcIndex, int length) {
567 throw new UnreplayableOperationException();
568 }
569
570 public void writeBytes(byte[] src) {
571 throw new UnreplayableOperationException();
572 }
573
574 public void writeBytes(ByteBuffer src) {
575 throw new UnreplayableOperationException();
576 }
577
578 public void writeBytes(ChannelBuffer src, int srcIndex, int length) {
579 throw new UnreplayableOperationException();
580 }
581
582 public void writeBytes(ChannelBuffer src, int length) {
583 throw new UnreplayableOperationException();
584 }
585
586 public void writeBytes(ChannelBuffer src) {
587 throw new UnreplayableOperationException();
588 }
589
590 public int writeBytes(InputStream in, int length) throws IOException {
591 throw new UnreplayableOperationException();
592 }
593
594 public int writeBytes(ScatteringByteChannel in, int length)
595 throws IOException {
596 throw new UnreplayableOperationException();
597 }
598
599 public void writeInt(int value) {
600 throw new UnreplayableOperationException();
601 }
602
603 public void writeLong(long value) {
604 throw new UnreplayableOperationException();
605 }
606
607 public void writeMedium(int value) {
608 throw new UnreplayableOperationException();
609 }
610
611 public void writeZero(int length) {
612 throw new UnreplayableOperationException();
613 }
614
615 public int writerIndex() {
616 return buf().writerIndex();
617 }
618
619 public void writerIndex(int writerIndex) {
620 throw new UnreplayableOperationException();
621 }
622
623 public void writeShort(int value) {
624 throw new UnreplayableOperationException();
625 }
626
627 public void writeChar(int value) {
628 throw new UnreplayableOperationException();
629 }
630
631 public void writeFloat(float value) {
632 throw new UnreplayableOperationException();
633 }
634
635 public void writeDouble(double value) {
636 throw new UnreplayableOperationException();
637 }
638
639 private void checkIndex(int index, int length) {
640 if (index + length > buf().writerIndex()) {
641 throw REPLAY;
642 }
643 }
644
645 private void checkReadableBytes(int readableBytes) {
646 if (buf().readableBytes() < readableBytes) {
647 throw REPLAY;
648 }
649 }
650 }
以上源码来自： 即时通讯网 - 即时通讯开发者社区！