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)
561 throws CharacterCodingException {
562 return buf.getString(fieldSize, decoder);
563 }
564
565 @Override
566 public String getString(CharsetDecoder decoder)
567 throws CharacterCodingException {
568 return buf.getString(decoder);
569 }
570
571 @Override
572 public String getPrefixedString(CharsetDecoder decoder)
573 throws CharacterCodingException {
574 return buf.getPrefixedString(decoder);
575 }
576
577 @Override
578 public String getPrefixedString(int prefixLength, CharsetDecoder decoder)
579 throws CharacterCodingException {
580 return buf.getPrefixedString(prefixLength, decoder);
581 }
582
583 @Override
584 public IoBuffer putString(CharSequence in, int fieldSize,
585 CharsetEncoder encoder) throws CharacterCodingException {
586 buf.putString(in, fieldSize, encoder);
587 return this;
588 }
589
590 @Override
591 public IoBuffer putString(CharSequence in, CharsetEncoder encoder)
592 throws CharacterCodingException {
593 buf.putString(in, encoder);
594 return this;
595 }
596
597 @Override
598 public IoBuffer putPrefixedString(CharSequence in, CharsetEncoder encoder)
599 throws CharacterCodingException {
600 buf.putPrefixedString(in, encoder);
601 return this;
602 }
603
604 @Override
605 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
606 CharsetEncoder encoder) throws CharacterCodingException {
607 buf.putPrefixedString(in, prefixLength, encoder);
608 return this;
609 }
610
611 @Override
612 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
613 int padding, CharsetEncoder encoder)
614 throws CharacterCodingException {
615 buf.putPrefixedString(in, prefixLength, padding, encoder);
616 return this;
617 }
618
619 @Override
620 public IoBuffer putPrefixedString(CharSequence in, int prefixLength,
621 int padding, byte padValue, CharsetEncoder encoder)
622 throws CharacterCodingException {
623 buf.putPrefixedString(in, prefixLength, padding, padValue, encoder);
624 return this;
625 }
626
627 @Override
628 public IoBuffer skip(int size) {
629 buf.skip(size);
630 return this;
631 }
632
633 @Override
634 public IoBuffer fill(byte value, int size) {
635 buf.fill(value, size);
636 return this;
637 }
638
639 @Override
640 public IoBuffer fillAndReset(byte value, int size) {
641 buf.fillAndReset(value, size);
642 return this;
643 }
644
645 @Override
646 public IoBuffer fill(int size) {
647 buf.fill(size);
648 return this;
649 }
650
651 @Override
652 public IoBuffer fillAndReset(int size) {
653 buf.fillAndReset(size);
654 return this;
655 }
656
657 @Override
658 public boolean isAutoExpand() {
659 return buf.isAutoExpand();
660 }
661
662 @Override
663 public IoBuffer setAutoExpand(boolean autoExpand) {
664 buf.setAutoExpand(autoExpand);
665 return this;
666 }
667
668 @Override
669 public IoBuffer expand(int pos, int expectedRemaining) {
670 buf.expand(pos, expectedRemaining);
671 return this;
672 }
673
674 @Override
675 public IoBuffer expand(int expectedRemaining) {
676 buf.expand(expectedRemaining);
677 return this;
678 }
679
680 @Override
681 public Object getObject() throws ClassNotFoundException {
682 return buf.getObject();
683 }
684
685 @Override
686 public Object getObject(ClassLoader classLoader)
687 throws ClassNotFoundException {
688 return buf.getObject(classLoader);
689 }
690
691 @Override
692 public IoBuffer putObject(Object o) {
693 buf.putObject(o);
694 return this;
695 }
696
697 @Override
698 public InputStream asInputStream() {
699 return buf.asInputStream();
700 }
701
702 @Override
703 public OutputStream asOutputStream() {
704 return buf.asOutputStream();
705 }
706
707 @Override
708 public IoBuffer duplicate() {
709 return buf.duplicate();
710 }
711
712 @Override
713 public IoBuffer slice() {
714 return buf.slice();
715 }
716
717 @Override
718 public IoBuffer asReadOnlyBuffer() {
719 return buf.asReadOnlyBuffer();
720 }
721
722 @Override
723 public byte[] array() {
724 return buf.array();
725 }
726
727 @Override
728 public int arrayOffset() {
729 return buf.arrayOffset();
730 }
731
732 @Override
733 public int minimumCapacity() {
734 return buf.minimumCapacity();
735 }
736
737 @Override
738 public IoBuffer minimumCapacity(int minimumCapacity) {
739 buf.minimumCapacity(minimumCapacity);
740 return this;
741 }
742
743 @Override
744 public IoBuffer capacity(int newCapacity) {
745 buf.capacity(newCapacity);
746 return this;
747 }
748
749 @Override
750 public boolean isReadOnly() {
751 return buf.isReadOnly();
752 }
753
754 @Override
755 public int markValue() {
756 return buf.markValue();
757 }
758
759 @Override
760 public boolean hasArray() {
761 return buf.hasArray();
762 }
763
764 @Override
765 public void free() {
766 buf.free();
767 }
768
769 @Override
770 public boolean isDerived() {
771 return buf.isDerived();
772 }
773
774 @Override
775 public boolean isAutoShrink() {
776 return buf.isAutoShrink();
777 }
778
779 @Override
780 public IoBuffer setAutoShrink(boolean autoShrink) {
781 buf.setAutoShrink(autoShrink);
782 return this;
783 }
784
785 @Override
786 public IoBuffer shrink() {
787 buf.shrink();
788 return this;
789 }
790
791 @Override
792 public int getMediumInt() {
793 return buf.getMediumInt();
794 }
795
796 @Override
797 public int getUnsignedMediumInt() {
798 return buf.getUnsignedMediumInt();
799 }
800
801 @Override
802 public int getMediumInt(int index) {
803 return buf.getMediumInt(index);
804 }
805
806 @Override
807 public int getUnsignedMediumInt(int index) {
808 return buf.getUnsignedMediumInt(index);
809 }
810
811 @Override
812 public IoBuffer putMediumInt(int value) {
813 buf.putMediumInt(value);
814 return this;
815 }
816
817 @Override
818 public IoBuffer putMediumInt(int index, int value) {
819 buf.putMediumInt(index, value);
820 return this;
821 }
822
823 @Override
824 public String getHexDump(int lengthLimit) {
825 return buf.getHexDump(lengthLimit);
826 }
827
828 @Override
829 public boolean prefixedDataAvailable(int prefixLength) {
830 return buf.prefixedDataAvailable(prefixLength);
831 }
832
833 @Override
834 public boolean prefixedDataAvailable(int prefixLength, int maxDataLength) {
835 return buf.prefixedDataAvailable(prefixLength, maxDataLength);
836 }
837
838 @Override
839 public int indexOf(byte b) {
840 return buf.indexOf(b);
841 }
842
843 @Override
844 public <E extends Enum<E>> E getEnum(Class<E> enumClass) {
845 return buf.getEnum(enumClass);
846 }
847
848 @Override
849 public <E extends Enum<E>> E getEnum(int index, Class<E> enumClass) {
850 return buf.getEnum(index, enumClass);
851 }
852
853 @Override
854 public <E extends Enum<E>> E getEnumShort(Class<E> enumClass) {
855 return buf.getEnumShort(enumClass);
856 }
857
858 @Override
859 public <E extends Enum<E>> E getEnumShort(int index, Class<E> enumClass) {
860 return buf.getEnumShort(index, enumClass);
861 }
862
863 @Override
864 public <E extends Enum<E>> E getEnumInt(Class<E> enumClass) {
865 return buf.getEnumInt(enumClass);
866 }
867
868 @Override
869 public <E extends Enum<E>> E getEnumInt(int index, Class<E> enumClass) {
870 return buf.getEnumInt(index, enumClass);
871 }
872
873 @Override
874 public IoBuffer putEnum(Enum<?> e) {
875 buf.putEnum(e);
876 return this;
877 }
878
879 @Override
880 public IoBuffer putEnum(int index, Enum<?> e) {
881 buf.putEnum(index, e);
882 return this;
883 }
884
885 @Override
886 public IoBuffer putEnumShort(Enum<?> e) {
887 buf.putEnumShort(e);
888 return this;
889 }
890
891 @Override
892 public IoBuffer putEnumShort(int index, Enum<?> e) {
893 buf.putEnumShort(index, e);
894 return this;
895 }
896
897 @Override
898 public IoBuffer putEnumInt(Enum<?> e) {
899 buf.putEnumInt(e);
900 return this;
901 }
902
903 @Override
904 public IoBuffer putEnumInt(int index, Enum<?> e) {
905 buf.putEnumInt(index, e);
906 return this;
907 }
908
909 @Override
910 public <E extends Enum<E>> EnumSet<E> getEnumSet(Class<E> enumClass) {
911 return buf.getEnumSet(enumClass);
912 }
913
914 @Override
915 public <E extends Enum<E>> EnumSet<E> getEnumSet(int index, Class<E> enumClass) {
916 return buf.getEnumSet(index, enumClass);
917 }
918
919 @Override
920 public <E extends Enum<E>> EnumSet<E> getEnumSetShort(Class<E> enumClass) {
921 return buf.getEnumSetShort(enumClass);
922 }
923
924 @Override
925 public <E extends Enum<E>> EnumSet<E> getEnumSetShort(int index, Class<E> enumClass) {
926 return buf.getEnumSetShort(index, enumClass);
927 }
928
929 @Override
930 public <E extends Enum<E>> EnumSet<E> getEnumSetInt(Class<E> enumClass) {
931 return buf.getEnumSetInt(enumClass);
932 }
933
934 @Override
935 public <E extends Enum<E>> EnumSet<E> getEnumSetInt(int index, Class<E> enumClass) {
936 return buf.getEnumSetInt(index, enumClass);
937 }
938
939 @Override
940 public <E extends Enum<E>> EnumSet<E> getEnumSetLong(Class<E> enumClass) {
941 return buf.getEnumSetLong(enumClass);
942 }
943
944 @Override
945 public <E extends Enum<E>> EnumSet<E> getEnumSetLong(int index, Class<E> enumClass) {
946 return buf.getEnumSetLong(index, enumClass);
947 }
948
949 @Override
950 public <E extends Enum<E>> IoBuffer putEnumSet(Set<E> set) {
951 buf.putEnumSet(set);
952 return this;
953 }
954
955 @Override
956 public <E extends Enum<E>> IoBuffer putEnumSet(int index, Set<E> set) {
957 buf.putEnumSet(index, set);
958 return this;
959 }
960
961 @Override
962 public <E extends Enum<E>> IoBuffer putEnumSetShort(Set<E> set) {
963 buf.putEnumSetShort(set);
964 return this;
965 }
966
967 @Override
968 public <E extends Enum<E>> IoBuffer putEnumSetShort(int index, Set<E> set) {
969 buf.putEnumSetShort(index, set);
970 return this;
971 }
972
973 @Override
974 public <E extends Enum<E>> IoBuffer putEnumSetInt(Set<E> set) {
975 buf.putEnumSetInt(set);
976 return this;
977 }
978
979 @Override
980 public <E extends Enum<E>> IoBuffer putEnumSetInt(int index, Set<E> set) {
981 buf.putEnumSetInt(index, set);
982 return this;
983 }
984
985 @Override
986 public <E extends Enum<E>> IoBuffer putEnumSetLong(Set<E> set) {
987 buf.putEnumSetLong(set);
988 return this;
989 }
990
991 @Override
992 public <E extends Enum<E>> IoBuffer putEnumSetLong(int index, Set<E> set) {
993 buf.putEnumSetLong(index, set);
994 return this;
995 }
996
997 @Override
998 public IoBuffer putUnsigned(byte value) {
999 buf.putUnsigned(value);
1000 return this;
1001 }
1002
1003 @Override
1004 public IoBuffer putUnsigned(int index, byte value) {
1005 buf.putUnsigned(index, value);
1006 return this;
1007 }
1008
1009 @Override
1010 public IoBuffer putUnsigned(short value) {
1011 buf.putUnsigned(value);
1012 return this;
1013 }
1014
1015 @Override
1016 public IoBuffer putUnsigned(int index, short value) {
1017 buf.putUnsigned(index, value);
1018 return this;
1019 }
1020
1021 @Override
1022 public IoBuffer putUnsigned(int value) {
1023 buf.putUnsigned(value);
1024 return this;
1025 }
1026
1027 @Override
1028 public IoBuffer putUnsigned(int index, int value) {
1029 buf.putUnsigned(index, value);
1030 return this;
1031 }
1032
1033 @Override
1034 public IoBuffer putUnsigned(long value) {
1035 buf.putUnsigned(value);
1036 return this;
1037 }
1038
1039 @Override
1040 public IoBuffer putUnsigned(int index, long value) {
1041 buf.putUnsigned(index, value);
1042 return this;
1043 }
1044 }