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