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.buffer;
21
22 import java.io.FilterOutputStream;
23 import java.io.InputStream;
24 import java.io.OutputStream;
25 import java.nio.ByteBuffer;
26 import java.nio.ByteOrder;
27 import java.nio.CharBuffer;
28 import java.nio.DoubleBuffer;
29 import java.nio.FloatBuffer;
30 import java.nio.IntBuffer;
31 import java.nio.LongBuffer;
32 import java.nio.ShortBuffer;
33 import java.nio.charset.CharacterCodingException;
34 import java.nio.charset.CharsetDecoder;
35 import java.nio.charset.CharsetEncoder;
36 import java.util.EnumSet;
37 import java.util.Set;
38
39
40
41
42
43
44
45
46
47
48
49 public class IoBufferWrapper extends IoBuffer {
50
51
52
53
54 private final IoBuffer buf;
55
56
57
58
59
60 protected IoBufferWrapper(IoBuffer buf) {
61 if (buf == null) {
62 throw new NullPointerException("buf");
63 }
64 this.buf = buf;
65 }
66
67
68
69
70 public IoBuffer getParentBuffer() {
71 return buf;
72 }
73
74 @Override
75 public boolean isDirect() {
76 return buf.isDirect();
77 }
78
79 @Override
80 public ByteBuffer buf() {
81 return buf.buf();
82 }
83
84 @Override
85 public int capacity() {
86 return buf.capacity();
87 }
88
89 @Override
90 public int position() {
91 return buf.position();
92 }
93
94 @Override
95 public IoBuffer position(int newPosition) {
96 buf.position(newPosition);
97 return this;
98 }
99
100 @Override
101 public int limit() {
102 return buf.limit();
103 }
104
105 @Override
106 public IoBuffer limit(int newLimit) {
107 buf.limit(newLimit);
108 return this;
109 }
110
111 @Override
112 public IoBuffer mark() {
113 buf.mark();
114 return this;
115 }
116
117 @Override
118 public IoBuffer reset() {
119 buf.reset();
120 return this;
121 }
122
123 @Override
124 public IoBuffer clear() {
125 buf.clear();
126 return this;
127 }
128
129 @Override
130 public IoBuffer sweep() {
131 buf.sweep();
132 return this;
133 }
134
135 @Override
136 public IoBuffer sweep(byte value) {
137 buf.sweep(value);
138 return this;
139 }
140
141 @Override
142 public IoBuffer flip() {
143 buf.flip();
144 return this;
145 }
146
147 @Override
148 public IoBuffer rewind() {
149 buf.rewind();
150 return this;
151 }
152
153 @Override
154 public int remaining() {
155 return buf.remaining();
156 }
157
158 @Override
159 public boolean hasRemaining() {
160 return buf.hasRemaining();
161 }
162
163 @Override
164 public byte get() {
165 return buf.get();
166 }
167
168 @Override
169 public short getUnsigned() {
170 return buf.getUnsigned();
171 }
172
173 @Override
174 public IoBuffer put(byte b) {
175 buf.put(b);
176 return this;
177 }
178
179 @Override
180 public byte get(int index) {
181 return buf.get(index);
182 }
183
184 @Override
185 public short getUnsigned(int index) {
186 return buf.getUnsigned(index);
187 }
188
189 @Override
190 public IoBuffer put(int index, byte b) {
191 buf.put(index, b);
192 return this;
193 }
194
195 @Override
196 public IoBuffer get(byte[] dst, int offset, int length) {
197 buf.get(dst, offset, length);
198 return this;
199 }
200
201 @Override
202 public IoBuffer getSlice(int index, int length) {
203 return buf.getSlice(index, length);
204 }
205
206 @Override
207 public IoBuffer getSlice(int length) {
208 return buf.getSlice(length);
209 }
210
211 @Override
212 public IoBuffer get(byte[] dst) {
213 buf.get(dst);
214 return this;
215 }
216
217 @Override
218 public IoBuffer put(IoBuffer src) {
219 buf.put(src);
220 return this;
221 }
222
223 @Override
224 public IoBuffer put(ByteBuffer src) {
225 buf.put(src);
226 return this;
227 }
228
229 @Override
230 public IoBuffer put(byte[] src, int offset, int length) {
231 buf.put(src, offset, length);
232 return this;
233 }
234
235 @Override
236 public IoBuffer put(byte[] src) {
237 buf.put(src);
238 return this;
239 }
240
241 @Override
242 public IoBuffer compact() {
243 buf.compact();
244 return this;
245 }
246
247 @Override
248 public String toString() {
249 return buf.toString();
250 }
251
252 @Override
253 public int hashCode() {
254 return buf.hashCode();
255 }
256
257 @Override
258 public boolean equals(Object ob) {
259 return buf.equals(ob);
260 }
261
262 public int compareTo(IoBuffer that) {
263 return buf.compareTo(that);
264 }
265
266 @Override
267 public ByteOrder order() {
268 return buf.order();
269 }
270
271 @Override
272 public IoBuffer order(ByteOrder bo) {
273 buf.order(bo);
274 return this;
275 }
276
277 @Override
278 public char getChar() {
279 return buf.getChar();
280 }
281
282 @Override
283 public IoBuffer putChar(char value) {
284 buf.putChar(value);
285 return this;
286 }
287
288 @Override
289 public char getChar(int index) {
290 return buf.getChar(index);
291 }
292
293 @Override
294 public IoBuffer putChar(int index, char value) {
295 buf.putChar(index, value);
296 return this;
297 }
298
299 @Override
300 public CharBuffer asCharBuffer() {
301 return buf.asCharBuffer();
302 }
303
304 @Override
305 public short getShort() {
306 return buf.getShort();
307 }
308
309 @Override
310 public int getUnsignedShort() {
311 return buf.getUnsignedShort();
312 }
313
314 @Override
315 public IoBuffer putShort(short value) {
316 buf.putShort(value);
317 return this;
318 }
319
320 @Override
321 public short getShort(int index) {
322 return buf.getShort(index);
323 }
324
325 @Override
326 public int getUnsignedShort(int index) {
327 return buf.getUnsignedShort(index);
328 }
329
330 @Override
331 public IoBuffer putShort(int index, short value) {
332 buf.putShort(index, value);
333 return this;
334 }
335
336 @Override
337 public ShortBuffer asShortBuffer() {
338 return buf.asShortBuffer();
339 }
340
341 @Override
342 public int getInt() {
343 return buf.getInt();
344 }
345
346 @Override
347 public long getUnsignedInt() {
348 return buf.getUnsignedInt();
349 }
350
351 @Override
352 public IoBuffer putInt(int value) {
353 buf.putInt(value);
354 return this;
355 }
356
357 @Override
358 public int getInt(int index) {
359 return buf.getInt(index);
360 }
361
362 @Override
363 public long getUnsignedInt(int index) {
364 return buf.getUnsignedInt(index);
365 }
366
367 @Override
368 public IoBuffer putInt(int index, int value) {
369 buf.putInt(index, value);
370 return this;
371 }
372
373 @Override
374 public IntBuffer asIntBuffer() {
375 return buf.asIntBuffer();
376 }
377
378 @Override
379 public long getLong() {
380 return buf.getLong();
381 }
382
383 @Override
384 public IoBuffer putLong(long value) {
385 buf.putLong(value);
386 return this;
387 }
388
389 @Override
390 public long getLong(int index) {
391 return buf.getLong(index);
392 }
393
394 @Override
395 public IoBuffer putLong(int index, long value) {
396 buf.putLong(index, value);
397 return this;
398 }
399
400 @Override
401 public LongBuffer asLongBuffer() {
402 return buf.asLongBuffer();
403 }
404
405 @Override
406 public float getFloat() {
407 return buf.getFloat();
408 }
409
410 @Override
411 public IoBuffer putFloat(float value) {
412 buf.putFloat(value);
413 return this;
414 }
415
416 @Override
417 public float getFloat(int index) {
418 return buf.getFloat(index);
419 }
420
421 @Override
422 public IoBuffer putFloat(int index, float value) {
423 buf.putFloat(index, value);
424 return this;
425 }
426
427 @Override
428 public FloatBuffer asFloatBuffer() {
429 return buf.asFloatBuffer();
430 }
431
432 @Override
433 public double getDouble() {
434 return buf.getDouble();
435 }
436
437 @Override
438 public IoBuffer putDouble(double value) {
439 buf.putDouble(value);
440 return this;
441 }
442
443 @Override
444 public double getDouble(int index) {
445 return buf.getDouble(index);
446 }
447
448 @Override
449 public IoBuffer putDouble(int index, double value) {
450 buf.putDouble(index, value);
451 return this;
452 }
453
454 @Override
455 public DoubleBuffer asDoubleBuffer() {
456 return buf.asDoubleBuffer();
457 }
458
459 @Override
460 public String getHexDump() {
461 return buf.getHexDump();
462 }
463
464 @Override
465 public String getString(int fieldSize, CharsetDecoder decoder)
466 throws CharacterCodingException {
467 return buf.getString(fieldSize, decoder);
468 }
469
470 @Override
471 public String getString(CharsetDecoder decoder)
472 throws CharacterCodingException {
473 return buf.getString(decoder);
474 }
475
476 @Override
477 public String getPrefixedString(CharsetDecoder decoder)
478 throws CharacterCodingException {
479 return buf.getPrefixedString(decoder);
480 }
481
482 @Override
483 public String getPrefixedString(int prefixLength, CharsetDecoder decoder)
484 throws CharacterCodingException {
485 return buf.getPrefixedString(prefixLength, decoder);
486 }
487
488 @Override
489 public IoBuffer putString(CharSequence in, int fieldSize,
490 CharsetEncoder encoder) throws CharacterCodingException {
491 buf.putString(in, fieldSize, encoder);
492 return this;
493 }
494
495 @Override
496 public IoBuffer putString(CharSequence in, CharsetEncoder encoder)
497 throws CharacterCodingException {
498 buf.putString(in, encoder);
499 return this;
500 }
501
502 @Override
503 public IoBuffer putPrefixedString(CharSequence in, CharsetEncoder encoder)
504 throws CharacterCodingException {
505 buf.putPrefixedString(in, encoder);
506 return this;
507 }
508
509 @Override
510 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
511 CharsetEncoder encoder) throws CharacterCodingException {
512 buf.putPrefixedString(in, prefixLength, encoder);
513 return this;
514 }
515
516 @Override
517 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
518 int padding, CharsetEncoder encoder)
519 throws CharacterCodingException {
520 buf.putPrefixedString(in, prefixLength, padding, encoder);
521 return this;
522 }
523
524 @Override
525 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
526 int padding, byte padValue, CharsetEncoder encoder)
527 throws CharacterCodingException {
528 buf.putPrefixedString(in, prefixLength, padding, padValue, encoder);
529 return this;
530 }
531
532 @Override
533 public IoBuffer skip(int size) {
534 buf.skip(size);
535 return this;
536 }
537
538 @Override
539 public IoBuffer fill(byte value, int size) {
540 buf.fill(value, size);
541 return this;
542 }
543
544 @Override
545 public IoBuffer fillAndReset(byte value, int size) {
546 buf.fillAndReset(value, size);
547 return this;
548 }
549
550 @Override
551 public IoBuffer fill(int size) {
552 buf.fill(size);
553 return this;
554 }
555
556 @Override
557 public IoBuffer fillAndReset(int size) {
558 buf.fillAndReset(size);
559 return this;
560 }
561
562 @Override
563 public boolean isAutoExpand() {
564 return buf.isAutoExpand();
565 }
566
567 @Override
568 public IoBuffer setAutoExpand(boolean autoExpand) {
569 buf.setAutoExpand(autoExpand);
570 return this;
571 }
572
573 @Override
574 public IoBuffer expand(int pos, int expectedRemaining) {
575 buf.expand(pos, expectedRemaining);
576 return this;
577 }
578
579 @Override
580 public IoBuffer expand(int expectedRemaining) {
581 buf.expand(expectedRemaining);
582 return this;
583 }
584
585 @Override
586 public Object getObject() throws ClassNotFoundException {
587 return buf.getObject();
588 }
589
590 @Override
591 public Object getObject(ClassLoader classLoader)
592 throws ClassNotFoundException {
593 return buf.getObject(classLoader);
594 }
595
596 @Override
597 public IoBuffer putObject(Object o) {
598 buf.putObject(o);
599 return this;
600 }
601
602 @Override
603 public InputStream asInputStream() {
604 return buf.asInputStream();
605 }
606
607 @Override
608 public OutputStream asOutputStream() {
609 return buf.asOutputStream();
610 }
611
612 @Override
613 public IoBuffer duplicate() {
614 return buf.duplicate();
615 }
616
617 @Override
618 public IoBuffer slice() {
619 return buf.slice();
620 }
621
622 @Override
623 public IoBuffer asReadOnlyBuffer() {
624 return buf.asReadOnlyBuffer();
625 }
626
627 @Override
628 public byte[] array() {
629 return buf.array();
630 }
631
632 @Override
633 public int arrayOffset() {
634 return buf.arrayOffset();
635 }
636
637 @Override
638 public int minimumCapacity() {
639 return buf.minimumCapacity();
640 }
641
642 @Override
643 public IoBuffer minimumCapacity(int minimumCapacity) {
644 buf.minimumCapacity(minimumCapacity);
645 return this;
646 }
647
648 @Override
649 public IoBuffer capacity(int newCapacity) {
650 buf.capacity(newCapacity);
651 return this;
652 }
653
654 @Override
655 public boolean isReadOnly() {
656 return buf.isReadOnly();
657 }
658
659 @Override
660 public int markValue() {
661 return buf.markValue();
662 }
663
664 @Override
665 public boolean hasArray() {
666 return buf.hasArray();
667 }
668
669 @Override
670 public void free() {
671 buf.free();
672 }
673
674 @Override
675 public boolean isDerived() {
676 return buf.isDerived();
677 }
678
679 @Override
680 public boolean isAutoShrink() {
681 return buf.isAutoShrink();
682 }
683
684 @Override
685 public IoBuffer setAutoShrink(boolean autoShrink) {
686 buf.setAutoShrink(autoShrink);
687 return this;
688 }
689
690 @Override
691 public IoBuffer shrink() {
692 buf.shrink();
693 return this;
694 }
695
696 @Override
697 public int getMediumInt() {
698 return buf.getMediumInt();
699 }
700
701 @Override
702 public int getUnsignedMediumInt() {
703 return buf.getUnsignedMediumInt();
704 }
705
706 @Override
707 public int getMediumInt(int index) {
708 return buf.getMediumInt(index);
709 }
710
711 @Override
712 public int getUnsignedMediumInt(int index) {
713 return buf.getUnsignedMediumInt(index);
714 }
715
716 @Override
717 public IoBuffer putMediumInt(int value) {
718 buf.putMediumInt(value);
719 return this;
720 }
721
722 @Override
723 public IoBuffer putMediumInt(int index, int value) {
724 buf.putMediumInt(index, value);
725 return this;
726 }
727
728 @Override
729 public String getHexDump(int lengthLimit) {
730 return buf.getHexDump(lengthLimit);
731 }
732
733 @Override
734 public boolean prefixedDataAvailable(int prefixLength) {
735 return buf.prefixedDataAvailable(prefixLength);
736 }
737
738 @Override
739 public boolean prefixedDataAvailable(int prefixLength, int maxDataLength) {
740 return buf.prefixedDataAvailable(prefixLength, maxDataLength);
741 }
742
743 @Override
744 public int indexOf(byte b) {
745 return buf.indexOf(b);
746 }
747
748 @Override
749 public <E extends Enum<E>> E getEnum(Class<E> enumClass) {
750 return buf.getEnum(enumClass);
751 }
752
753 @Override
754 public <E extends Enum<E>> E getEnum(int index, Class<E> enumClass) {
755 return buf.getEnum(index, enumClass);
756 }
757
758 @Override
759 public <E extends Enum<E>> E getEnumShort(Class<E> enumClass) {
760 return buf.getEnumShort(enumClass);
761 }
762
763 @Override
764 public <E extends Enum<E>> E getEnumShort(int index, Class<E> enumClass) {
765 return buf.getEnumShort(index, enumClass);
766 }
767
768 @Override
769 public <E extends Enum<E>> E getEnumInt(Class<E> enumClass) {
770 return buf.getEnumInt(enumClass);
771 }
772
773 @Override
774 public <E extends Enum<E>> E getEnumInt(int index, Class<E> enumClass) {
775 return buf.getEnumInt(index, enumClass);
776 }
777
778 @Override
779 public IoBuffer putEnum(Enum<?> e) {
780 buf.putEnum(e);
781 return this;
782 }
783
784 @Override
785 public IoBuffer putEnum(int index, Enum<?> e) {
786 buf.putEnum(index, e);
787 return this;
788 }
789
790 @Override
791 public IoBuffer putEnumShort(Enum<?> e) {
792 buf.putEnumShort(e);
793 return this;
794 }
795
796 @Override
797 public IoBuffer putEnumShort(int index, Enum<?> e) {
798 buf.putEnumShort(index, e);
799 return this;
800 }
801
802 @Override
803 public IoBuffer putEnumInt(Enum<?> e) {
804 buf.putEnumInt(e);
805 return this;
806 }
807
808 @Override
809 public IoBuffer putEnumInt(int index, Enum<?> e) {
810 buf.putEnumInt(index, e);
811 return this;
812 }
813
814 @Override
815 public <E extends Enum<E>> EnumSet<E> getEnumSet(Class<E> enumClass) {
816 return buf.getEnumSet(enumClass);
817 }
818
819 @Override
820 public <E extends Enum<E>> EnumSet<E> getEnumSet(int index, Class<E> enumClass) {
821 return buf.getEnumSet(index, enumClass);
822 }
823
824 @Override
825 public <E extends Enum<E>> EnumSet<E> getEnumSetShort(Class<E> enumClass) {
826 return buf.getEnumSetShort(enumClass);
827 }
828
829 @Override
830 public <E extends Enum<E>> EnumSet<E> getEnumSetShort(int index, Class<E> enumClass) {
831 return buf.getEnumSetShort(index, enumClass);
832 }
833
834 @Override
835 public <E extends Enum<E>> EnumSet<E> getEnumSetInt(Class<E> enumClass) {
836 return buf.getEnumSetInt(enumClass);
837 }
838
839 @Override
840 public <E extends Enum<E>> EnumSet<E> getEnumSetInt(int index, Class<E> enumClass) {
841 return buf.getEnumSetInt(index, enumClass);
842 }
843
844 @Override
845 public <E extends Enum<E>> EnumSet<E> getEnumSetLong(Class<E> enumClass) {
846 return buf.getEnumSetLong(enumClass);
847 }
848
849 @Override
850 public <E extends Enum<E>> EnumSet<E> getEnumSetLong(int index, Class<E> enumClass) {
851 return buf.getEnumSetLong(index, enumClass);
852 }
853
854 @Override
855 public <E extends Enum<E>> IoBuffer putEnumSet(Set<E> set) {
856 buf.putEnumSet(set);
857 return this;
858 }
859
860 @Override
861 public <E extends Enum<E>> IoBuffer putEnumSet(int index, Set<E> set) {
862 buf.putEnumSet(index, set);
863 return this;
864 }
865
866 @Override
867 public <E extends Enum<E>> IoBuffer putEnumSetShort(Set<E> set) {
868 buf.putEnumSetShort(set);
869 return this;
870 }
871
872 @Override
873 public <E extends Enum<E>> IoBuffer putEnumSetShort(int index, Set<E> set) {
874 buf.putEnumSetShort(index, set);
875 return this;
876 }
877
878 @Override
879 public <E extends Enum<E>> IoBuffer putEnumSetInt(Set<E> set) {
880 buf.putEnumSetInt(set);
881 return this;
882 }
883
884 @Override
885 public <E extends Enum<E>> IoBuffer putEnumSetInt(int index, Set<E> set) {
886 buf.putEnumSetInt(index, set);
887 return this;
888 }
889
890 @Override
891 public <E extends Enum<E>> IoBuffer putEnumSetLong(Set<E> set) {
892 buf.putEnumSetLong(set);
893 return this;
894 }
895
896 @Override
897 public <E extends Enum<E>> IoBuffer putEnumSetLong(int index, Set<E> set) {
898 buf.putEnumSetLong(index, set);
899 return this;
900 }
901 }