1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package io.netty.buffer;
17
18 import io.netty.util.ByteProcessor;
19
20 import java.io.IOException;
21 import java.io.InputStream;
22 import java.io.OutputStream;
23 import java.nio.ByteBuffer;
24 import java.nio.ByteOrder;
25 import java.nio.channels.FileChannel;
26 import java.nio.channels.GatheringByteChannel;
27 import java.nio.channels.ScatteringByteChannel;
28 import java.nio.charset.Charset;
29 import java.util.Iterator;
30 import java.util.List;
31
32 class WrappedCompositeByteBuf extends CompositeByteBuf {
33
34 private final CompositeByteBuf wrapped;
35
36 WrappedCompositeByteBuf(CompositeByteBuf wrapped) {
37 super(wrapped.alloc());
38 this.wrapped = wrapped;
39 }
40
41 @Override
42 public boolean release() {
43 return wrapped.release();
44 }
45
46 @Override
47 public boolean release(int decrement) {
48 return wrapped.release(decrement);
49 }
50
51 @Override
52 public final int maxCapacity() {
53 return wrapped.maxCapacity();
54 }
55
56 @Override
57 public final int readerIndex() {
58 return wrapped.readerIndex();
59 }
60
61 @Override
62 public final int writerIndex() {
63 return wrapped.writerIndex();
64 }
65
66 @Override
67 public final boolean isReadable() {
68 return wrapped.isReadable();
69 }
70
71 @Override
72 public final boolean isReadable(int numBytes) {
73 return wrapped.isReadable(numBytes);
74 }
75
76 @Override
77 public final boolean isWritable() {
78 return wrapped.isWritable();
79 }
80
81 @Override
82 public final boolean isWritable(int numBytes) {
83 return wrapped.isWritable(numBytes);
84 }
85
86 @Override
87 public final int readableBytes() {
88 return wrapped.readableBytes();
89 }
90
91 @Override
92 public final int writableBytes() {
93 return wrapped.writableBytes();
94 }
95
96 @Override
97 public final int maxWritableBytes() {
98 return wrapped.maxWritableBytes();
99 }
100
101 @Override
102 public int maxFastWritableBytes() {
103 return wrapped.maxFastWritableBytes();
104 }
105
106 @Override
107 public int ensureWritable(int minWritableBytes, boolean force) {
108 return wrapped.ensureWritable(minWritableBytes, force);
109 }
110
111 @Override
112 public ByteBuf order(ByteOrder endianness) {
113 return wrapped.order(endianness);
114 }
115
116 @Override
117 public boolean getBoolean(int index) {
118 return wrapped.getBoolean(index);
119 }
120
121 @Override
122 public short getUnsignedByte(int index) {
123 return wrapped.getUnsignedByte(index);
124 }
125
126 @Override
127 public short getShort(int index) {
128 return wrapped.getShort(index);
129 }
130
131 @Override
132 public short getShortLE(int index) {
133 return wrapped.getShortLE(index);
134 }
135
136 @Override
137 public int getUnsignedShort(int index) {
138 return wrapped.getUnsignedShort(index);
139 }
140
141 @Override
142 public int getUnsignedShortLE(int index) {
143 return wrapped.getUnsignedShortLE(index);
144 }
145
146 @Override
147 public int getUnsignedMedium(int index) {
148 return wrapped.getUnsignedMedium(index);
149 }
150
151 @Override
152 public int getUnsignedMediumLE(int index) {
153 return wrapped.getUnsignedMediumLE(index);
154 }
155
156 @Override
157 public int getMedium(int index) {
158 return wrapped.getMedium(index);
159 }
160
161 @Override
162 public int getMediumLE(int index) {
163 return wrapped.getMediumLE(index);
164 }
165
166 @Override
167 public int getInt(int index) {
168 return wrapped.getInt(index);
169 }
170
171 @Override
172 public int getIntLE(int index) {
173 return wrapped.getIntLE(index);
174 }
175
176 @Override
177 public long getUnsignedInt(int index) {
178 return wrapped.getUnsignedInt(index);
179 }
180
181 @Override
182 public long getUnsignedIntLE(int index) {
183 return wrapped.getUnsignedIntLE(index);
184 }
185
186 @Override
187 public long getLong(int index) {
188 return wrapped.getLong(index);
189 }
190
191 @Override
192 public long getLongLE(int index) {
193 return wrapped.getLongLE(index);
194 }
195
196 @Override
197 public char getChar(int index) {
198 return wrapped.getChar(index);
199 }
200
201 @Override
202 public float getFloat(int index) {
203 return wrapped.getFloat(index);
204 }
205
206 @Override
207 public double getDouble(int index) {
208 return wrapped.getDouble(index);
209 }
210
211 @Override
212 public ByteBuf setShortLE(int index, int value) {
213 return wrapped.setShortLE(index, value);
214 }
215
216 @Override
217 public ByteBuf setMediumLE(int index, int value) {
218 return wrapped.setMediumLE(index, value);
219 }
220
221 @Override
222 public ByteBuf setIntLE(int index, int value) {
223 return wrapped.setIntLE(index, value);
224 }
225
226 @Override
227 public ByteBuf setLongLE(int index, long value) {
228 return wrapped.setLongLE(index, value);
229 }
230
231 @Override
232 public byte readByte() {
233 return wrapped.readByte();
234 }
235
236 @Override
237 public boolean readBoolean() {
238 return wrapped.readBoolean();
239 }
240
241 @Override
242 public short readUnsignedByte() {
243 return wrapped.readUnsignedByte();
244 }
245
246 @Override
247 public short readShort() {
248 return wrapped.readShort();
249 }
250
251 @Override
252 public short readShortLE() {
253 return wrapped.readShortLE();
254 }
255
256 @Override
257 public int readUnsignedShort() {
258 return wrapped.readUnsignedShort();
259 }
260
261 @Override
262 public int readUnsignedShortLE() {
263 return wrapped.readUnsignedShortLE();
264 }
265
266 @Override
267 public int readMedium() {
268 return wrapped.readMedium();
269 }
270
271 @Override
272 public int readMediumLE() {
273 return wrapped.readMediumLE();
274 }
275
276 @Override
277 public int readUnsignedMedium() {
278 return wrapped.readUnsignedMedium();
279 }
280
281 @Override
282 public int readUnsignedMediumLE() {
283 return wrapped.readUnsignedMediumLE();
284 }
285
286 @Override
287 public int readInt() {
288 return wrapped.readInt();
289 }
290
291 @Override
292 public int readIntLE() {
293 return wrapped.readIntLE();
294 }
295
296 @Override
297 public long readUnsignedInt() {
298 return wrapped.readUnsignedInt();
299 }
300
301 @Override
302 public long readUnsignedIntLE() {
303 return wrapped.readUnsignedIntLE();
304 }
305
306 @Override
307 public long readLong() {
308 return wrapped.readLong();
309 }
310
311 @Override
312 public long readLongLE() {
313 return wrapped.readLongLE();
314 }
315
316 @Override
317 public char readChar() {
318 return wrapped.readChar();
319 }
320
321 @Override
322 public float readFloat() {
323 return wrapped.readFloat();
324 }
325
326 @Override
327 public double readDouble() {
328 return wrapped.readDouble();
329 }
330
331 @Override
332 public ByteBuf readBytes(int length) {
333 return wrapped.readBytes(length);
334 }
335
336 @Override
337 public ByteBuf slice() {
338 return wrapped.slice();
339 }
340
341 @Override
342 public ByteBuf retainedSlice() {
343 return wrapped.retainedSlice();
344 }
345
346 @Override
347 public ByteBuf slice(int index, int length) {
348 return wrapped.slice(index, length);
349 }
350
351 @Override
352 public ByteBuf retainedSlice(int index, int length) {
353 return wrapped.retainedSlice(index, length);
354 }
355
356 @Override
357 public ByteBuffer nioBuffer() {
358 return wrapped.nioBuffer();
359 }
360
361 @Override
362 public String toString(Charset charset) {
363 return wrapped.toString(charset);
364 }
365
366 @Override
367 public String toString(int index, int length, Charset charset) {
368 return wrapped.toString(index, length, charset);
369 }
370
371 @Override
372 public int indexOf(int fromIndex, int toIndex, byte value) {
373 return wrapped.indexOf(fromIndex, toIndex, value);
374 }
375
376 @Override
377 public int bytesBefore(byte value) {
378 return wrapped.bytesBefore(value);
379 }
380
381 @Override
382 public int bytesBefore(int length, byte value) {
383 return wrapped.bytesBefore(length, value);
384 }
385
386 @Override
387 public int bytesBefore(int index, int length, byte value) {
388 return wrapped.bytesBefore(index, length, value);
389 }
390
391 @Override
392 public int forEachByte(ByteProcessor processor) {
393 return wrapped.forEachByte(processor);
394 }
395
396 @Override
397 public int forEachByte(int index, int length, ByteProcessor processor) {
398 return wrapped.forEachByte(index, length, processor);
399 }
400
401 @Override
402 public int forEachByteDesc(ByteProcessor processor) {
403 return wrapped.forEachByteDesc(processor);
404 }
405
406 @Override
407 public int forEachByteDesc(int index, int length, ByteProcessor processor) {
408 return wrapped.forEachByteDesc(index, length, processor);
409 }
410
411 @Override
412 public final int hashCode() {
413 return wrapped.hashCode();
414 }
415
416 @Override
417 public final boolean equals(Object o) {
418 return wrapped.equals(o);
419 }
420
421 @Override
422 public final int compareTo(ByteBuf that) {
423 return wrapped.compareTo(that);
424 }
425
426 @Override
427 public final int refCnt() {
428 return wrapped.refCnt();
429 }
430
431 @Override
432 final boolean isAccessible() {
433 return wrapped.isAccessible();
434 }
435
436 @Override
437 public ByteBuf duplicate() {
438 return wrapped.duplicate();
439 }
440
441 @Override
442 public ByteBuf retainedDuplicate() {
443 return wrapped.retainedDuplicate();
444 }
445
446 @Override
447 public ByteBuf readSlice(int length) {
448 return wrapped.readSlice(length);
449 }
450
451 @Override
452 public ByteBuf readRetainedSlice(int length) {
453 return wrapped.readRetainedSlice(length);
454 }
455
456 @Override
457 public int readBytes(GatheringByteChannel out, int length) throws IOException {
458 return wrapped.readBytes(out, length);
459 }
460
461 @Override
462 public ByteBuf writeShortLE(int value) {
463 return wrapped.writeShortLE(value);
464 }
465
466 @Override
467 public ByteBuf writeMediumLE(int value) {
468 return wrapped.writeMediumLE(value);
469 }
470
471 @Override
472 public ByteBuf writeIntLE(int value) {
473 return wrapped.writeIntLE(value);
474 }
475
476 @Override
477 public ByteBuf writeLongLE(long value) {
478 return wrapped.writeLongLE(value);
479 }
480
481 @Override
482 public int writeBytes(InputStream in, int length) throws IOException {
483 return wrapped.writeBytes(in, length);
484 }
485
486 @Override
487 public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
488 return wrapped.writeBytes(in, length);
489 }
490
491 @Override
492 public ByteBuf copy() {
493 return wrapped.copy();
494 }
495
496 @Override
497 public CompositeByteBuf addComponent(ByteBuf buffer) {
498 wrapped.addComponent(buffer);
499 return this;
500 }
501
502 @Override
503 public CompositeByteBuf addComponents(ByteBuf... buffers) {
504 wrapped.addComponents(buffers);
505 return this;
506 }
507
508 @Override
509 public CompositeByteBuf addComponents(Iterable<ByteBuf> buffers) {
510 wrapped.addComponents(buffers);
511 return this;
512 }
513
514 @Override
515 public CompositeByteBuf addComponent(int cIndex, ByteBuf buffer) {
516 wrapped.addComponent(cIndex, buffer);
517 return this;
518 }
519
520 @Override
521 public CompositeByteBuf addComponents(int cIndex, ByteBuf... buffers) {
522 wrapped.addComponents(cIndex, buffers);
523 return this;
524 }
525
526 @Override
527 public CompositeByteBuf addComponents(int cIndex, Iterable<ByteBuf> buffers) {
528 wrapped.addComponents(cIndex, buffers);
529 return this;
530 }
531
532 @Override
533 public CompositeByteBuf addComponent(boolean increaseWriterIndex, ByteBuf buffer) {
534 wrapped.addComponent(increaseWriterIndex, buffer);
535 return this;
536 }
537
538 @Override
539 public CompositeByteBuf addComponents(boolean increaseWriterIndex, ByteBuf... buffers) {
540 wrapped.addComponents(increaseWriterIndex, buffers);
541 return this;
542 }
543
544 @Override
545 public CompositeByteBuf addComponents(boolean increaseWriterIndex, Iterable<ByteBuf> buffers) {
546 wrapped.addComponents(increaseWriterIndex, buffers);
547 return this;
548 }
549
550 @Override
551 public CompositeByteBuf addComponent(boolean increaseWriterIndex, int cIndex, ByteBuf buffer) {
552 wrapped.addComponent(increaseWriterIndex, cIndex, buffer);
553 return this;
554 }
555
556 @Override
557 public CompositeByteBuf addFlattenedComponents(boolean increaseWriterIndex, ByteBuf buffer) {
558 wrapped.addFlattenedComponents(increaseWriterIndex, buffer);
559 return this;
560 }
561
562 @Override
563 public CompositeByteBuf removeComponent(int cIndex) {
564 wrapped.removeComponent(cIndex);
565 return this;
566 }
567
568 @Override
569 public CompositeByteBuf removeComponents(int cIndex, int numComponents) {
570 wrapped.removeComponents(cIndex, numComponents);
571 return this;
572 }
573
574 @Override
575 public Iterator<ByteBuf> iterator() {
576 return wrapped.iterator();
577 }
578
579 @Override
580 public List<ByteBuf> decompose(int offset, int length) {
581 return wrapped.decompose(offset, length);
582 }
583
584 @Override
585 public final boolean isDirect() {
586 return wrapped.isDirect();
587 }
588
589 @Override
590 public final boolean hasArray() {
591 return wrapped.hasArray();
592 }
593
594 @Override
595 public final byte[] array() {
596 return wrapped.array();
597 }
598
599 @Override
600 public final int arrayOffset() {
601 return wrapped.arrayOffset();
602 }
603
604 @Override
605 public final boolean hasMemoryAddress() {
606 return wrapped.hasMemoryAddress();
607 }
608
609 @Override
610 public final long memoryAddress() {
611 return wrapped.memoryAddress();
612 }
613
614 @Override
615 public final int capacity() {
616 return wrapped.capacity();
617 }
618
619 @Override
620 public CompositeByteBuf capacity(int newCapacity) {
621 wrapped.capacity(newCapacity);
622 return this;
623 }
624
625 @Override
626 public final ByteBufAllocator alloc() {
627 return wrapped.alloc();
628 }
629
630 @Override
631 public final ByteOrder order() {
632 return wrapped.order();
633 }
634
635 @Override
636 public final int numComponents() {
637 return wrapped.numComponents();
638 }
639
640 @Override
641 public final int maxNumComponents() {
642 return wrapped.maxNumComponents();
643 }
644
645 @Override
646 public final int toComponentIndex(int offset) {
647 return wrapped.toComponentIndex(offset);
648 }
649
650 @Override
651 public final int toByteIndex(int cIndex) {
652 return wrapped.toByteIndex(cIndex);
653 }
654
655 @Override
656 public byte getByte(int index) {
657 return wrapped.getByte(index);
658 }
659
660 @Override
661 protected final byte _getByte(int index) {
662 return wrapped._getByte(index);
663 }
664
665 @Override
666 protected final short _getShort(int index) {
667 return wrapped._getShort(index);
668 }
669
670 @Override
671 protected final short _getShortLE(int index) {
672 return wrapped._getShortLE(index);
673 }
674
675 @Override
676 protected final int _getUnsignedMedium(int index) {
677 return wrapped._getUnsignedMedium(index);
678 }
679
680 @Override
681 protected final int _getUnsignedMediumLE(int index) {
682 return wrapped._getUnsignedMediumLE(index);
683 }
684
685 @Override
686 protected final int _getInt(int index) {
687 return wrapped._getInt(index);
688 }
689
690 @Override
691 protected final int _getIntLE(int index) {
692 return wrapped._getIntLE(index);
693 }
694
695 @Override
696 protected final long _getLong(int index) {
697 return wrapped._getLong(index);
698 }
699
700 @Override
701 protected final long _getLongLE(int index) {
702 return wrapped._getLongLE(index);
703 }
704
705 @Override
706 public CompositeByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
707 wrapped.getBytes(index, dst, dstIndex, length);
708 return this;
709 }
710
711 @Override
712 public CompositeByteBuf getBytes(int index, ByteBuffer dst) {
713 wrapped.getBytes(index, dst);
714 return this;
715 }
716
717 @Override
718 public CompositeByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
719 wrapped.getBytes(index, dst, dstIndex, length);
720 return this;
721 }
722
723 @Override
724 public int getBytes(int index, GatheringByteChannel out, int length) throws IOException {
725 return wrapped.getBytes(index, out, length);
726 }
727
728 @Override
729 public CompositeByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
730 wrapped.getBytes(index, out, length);
731 return this;
732 }
733
734 @Override
735 public CompositeByteBuf setByte(int index, int value) {
736 wrapped.setByte(index, value);
737 return this;
738 }
739
740 @Override
741 protected final void _setByte(int index, int value) {
742 wrapped._setByte(index, value);
743 }
744
745 @Override
746 public CompositeByteBuf setShort(int index, int value) {
747 wrapped.setShort(index, value);
748 return this;
749 }
750
751 @Override
752 protected final void _setShort(int index, int value) {
753 wrapped._setShort(index, value);
754 }
755
756 @Override
757 protected final void _setShortLE(int index, int value) {
758 wrapped._setShortLE(index, value);
759 }
760
761 @Override
762 public CompositeByteBuf setMedium(int index, int value) {
763 wrapped.setMedium(index, value);
764 return this;
765 }
766
767 @Override
768 protected final void _setMedium(int index, int value) {
769 wrapped._setMedium(index, value);
770 }
771
772 @Override
773 protected final void _setMediumLE(int index, int value) {
774 wrapped._setMediumLE(index, value);
775 }
776
777 @Override
778 public CompositeByteBuf setInt(int index, int value) {
779 wrapped.setInt(index, value);
780 return this;
781 }
782
783 @Override
784 protected final void _setInt(int index, int value) {
785 wrapped._setInt(index, value);
786 }
787
788 @Override
789 protected final void _setIntLE(int index, int value) {
790 wrapped._setIntLE(index, value);
791 }
792
793 @Override
794 public CompositeByteBuf setLong(int index, long value) {
795 wrapped.setLong(index, value);
796 return this;
797 }
798
799 @Override
800 protected final void _setLong(int index, long value) {
801 wrapped._setLong(index, value);
802 }
803
804 @Override
805 protected final void _setLongLE(int index, long value) {
806 wrapped._setLongLE(index, value);
807 }
808
809 @Override
810 public CompositeByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
811 wrapped.setBytes(index, src, srcIndex, length);
812 return this;
813 }
814
815 @Override
816 public CompositeByteBuf setBytes(int index, ByteBuffer src) {
817 wrapped.setBytes(index, src);
818 return this;
819 }
820
821 @Override
822 public CompositeByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
823 wrapped.setBytes(index, src, srcIndex, length);
824 return this;
825 }
826
827 @Override
828 public int setBytes(int index, InputStream in, int length) throws IOException {
829 return wrapped.setBytes(index, in, length);
830 }
831
832 @Override
833 public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
834 return wrapped.setBytes(index, in, length);
835 }
836
837 @Override
838 public ByteBuf copy(int index, int length) {
839 return wrapped.copy(index, length);
840 }
841
842 @Override
843 public final ByteBuf component(int cIndex) {
844 return wrapped.component(cIndex);
845 }
846
847 @Override
848 public final ByteBuf componentAtOffset(int offset) {
849 return wrapped.componentAtOffset(offset);
850 }
851
852 @Override
853 public final ByteBuf internalComponent(int cIndex) {
854 return wrapped.internalComponent(cIndex);
855 }
856
857 @Override
858 public final ByteBuf internalComponentAtOffset(int offset) {
859 return wrapped.internalComponentAtOffset(offset);
860 }
861
862 @Override
863 public int nioBufferCount() {
864 return wrapped.nioBufferCount();
865 }
866
867 @Override
868 public ByteBuffer internalNioBuffer(int index, int length) {
869 return wrapped.internalNioBuffer(index, length);
870 }
871
872 @Override
873 public ByteBuffer nioBuffer(int index, int length) {
874 return wrapped.nioBuffer(index, length);
875 }
876
877 @Override
878 public ByteBuffer[] nioBuffers(int index, int length) {
879 return wrapped.nioBuffers(index, length);
880 }
881
882 @Override
883 public CompositeByteBuf consolidate() {
884 wrapped.consolidate();
885 return this;
886 }
887
888 @Override
889 public CompositeByteBuf consolidate(int cIndex, int numComponents) {
890 wrapped.consolidate(cIndex, numComponents);
891 return this;
892 }
893
894 @Override
895 public CompositeByteBuf discardReadComponents() {
896 wrapped.discardReadComponents();
897 return this;
898 }
899
900 @Override
901 public CompositeByteBuf discardReadBytes() {
902 wrapped.discardReadBytes();
903 return this;
904 }
905
906 @Override
907 public final String toString() {
908 return wrapped.toString();
909 }
910
911 @Override
912 public final CompositeByteBuf readerIndex(int readerIndex) {
913 wrapped.readerIndex(readerIndex);
914 return this;
915 }
916
917 @Override
918 public final CompositeByteBuf writerIndex(int writerIndex) {
919 wrapped.writerIndex(writerIndex);
920 return this;
921 }
922
923 @Override
924 public final CompositeByteBuf setIndex(int readerIndex, int writerIndex) {
925 wrapped.setIndex(readerIndex, writerIndex);
926 return this;
927 }
928
929 @Override
930 public final CompositeByteBuf clear() {
931 wrapped.clear();
932 return this;
933 }
934
935 @Override
936 public final CompositeByteBuf markReaderIndex() {
937 wrapped.markReaderIndex();
938 return this;
939 }
940
941 @Override
942 public final CompositeByteBuf resetReaderIndex() {
943 wrapped.resetReaderIndex();
944 return this;
945 }
946
947 @Override
948 public final CompositeByteBuf markWriterIndex() {
949 wrapped.markWriterIndex();
950 return this;
951 }
952
953 @Override
954 public final CompositeByteBuf resetWriterIndex() {
955 wrapped.resetWriterIndex();
956 return this;
957 }
958
959 @Override
960 public CompositeByteBuf ensureWritable(int minWritableBytes) {
961 wrapped.ensureWritable(minWritableBytes);
962 return this;
963 }
964
965 @Override
966 public CompositeByteBuf getBytes(int index, ByteBuf dst) {
967 wrapped.getBytes(index, dst);
968 return this;
969 }
970
971 @Override
972 public CompositeByteBuf getBytes(int index, ByteBuf dst, int length) {
973 wrapped.getBytes(index, dst, length);
974 return this;
975 }
976
977 @Override
978 public CompositeByteBuf getBytes(int index, byte[] dst) {
979 wrapped.getBytes(index, dst);
980 return this;
981 }
982
983 @Override
984 public CompositeByteBuf setBoolean(int index, boolean value) {
985 wrapped.setBoolean(index, value);
986 return this;
987 }
988
989 @Override
990 public CompositeByteBuf setChar(int index, int value) {
991 wrapped.setChar(index, value);
992 return this;
993 }
994
995 @Override
996 public CompositeByteBuf setFloat(int index, float value) {
997 wrapped.setFloat(index, value);
998 return this;
999 }
1000
1001 @Override
1002 public CompositeByteBuf setDouble(int index, double value) {
1003 wrapped.setDouble(index, value);
1004 return this;
1005 }
1006
1007 @Override
1008 public CompositeByteBuf setBytes(int index, ByteBuf src) {
1009 wrapped.setBytes(index, src);
1010 return this;
1011 }
1012
1013 @Override
1014 public CompositeByteBuf setBytes(int index, ByteBuf src, int length) {
1015 wrapped.setBytes(index, src, length);
1016 return this;
1017 }
1018
1019 @Override
1020 public CompositeByteBuf setBytes(int index, byte[] src) {
1021 wrapped.setBytes(index, src);
1022 return this;
1023 }
1024
1025 @Override
1026 public CompositeByteBuf setZero(int index, int length) {
1027 wrapped.setZero(index, length);
1028 return this;
1029 }
1030
1031 @Override
1032 public CompositeByteBuf readBytes(ByteBuf dst) {
1033 wrapped.readBytes(dst);
1034 return this;
1035 }
1036
1037 @Override
1038 public CompositeByteBuf readBytes(ByteBuf dst, int length) {
1039 wrapped.readBytes(dst, length);
1040 return this;
1041 }
1042
1043 @Override
1044 public CompositeByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
1045 wrapped.readBytes(dst, dstIndex, length);
1046 return this;
1047 }
1048
1049 @Override
1050 public CompositeByteBuf readBytes(byte[] dst) {
1051 wrapped.readBytes(dst);
1052 return this;
1053 }
1054
1055 @Override
1056 public CompositeByteBuf readBytes(byte[] dst, int dstIndex, int length) {
1057 wrapped.readBytes(dst, dstIndex, length);
1058 return this;
1059 }
1060
1061 @Override
1062 public CompositeByteBuf readBytes(ByteBuffer dst) {
1063 wrapped.readBytes(dst);
1064 return this;
1065 }
1066
1067 @Override
1068 public CompositeByteBuf readBytes(OutputStream out, int length) throws IOException {
1069 wrapped.readBytes(out, length);
1070 return this;
1071 }
1072
1073 @Override
1074 public int getBytes(int index, FileChannel out, long position, int length) throws IOException {
1075 return wrapped.getBytes(index, out, position, length);
1076 }
1077
1078 @Override
1079 public int setBytes(int index, FileChannel in, long position, int length) throws IOException {
1080 return wrapped.setBytes(index, in, position, length);
1081 }
1082
1083 @Override
1084 public boolean isReadOnly() {
1085 return wrapped.isReadOnly();
1086 }
1087
1088 @Override
1089 public ByteBuf asReadOnly() {
1090 return wrapped.asReadOnly();
1091 }
1092
1093 @Override
1094 protected SwappedByteBuf newSwappedByteBuf() {
1095 return wrapped.newSwappedByteBuf();
1096 }
1097
1098 @Override
1099 public CharSequence getCharSequence(int index, int length, Charset charset) {
1100 return wrapped.getCharSequence(index, length, charset);
1101 }
1102
1103 @Override
1104 public CharSequence readCharSequence(int length, Charset charset) {
1105 return wrapped.readCharSequence(length, charset);
1106 }
1107
1108 @Override
1109 public int setCharSequence(int index, CharSequence sequence, Charset charset) {
1110 return wrapped.setCharSequence(index, sequence, charset);
1111 }
1112
1113 @Override
1114 public int readBytes(FileChannel out, long position, int length) throws IOException {
1115 return wrapped.readBytes(out, position, length);
1116 }
1117
1118 @Override
1119 public int writeBytes(FileChannel in, long position, int length) throws IOException {
1120 return wrapped.writeBytes(in, position, length);
1121 }
1122
1123 @Override
1124 public int writeCharSequence(CharSequence sequence, Charset charset) {
1125 return wrapped.writeCharSequence(sequence, charset);
1126 }
1127
1128 @Override
1129 public CompositeByteBuf skipBytes(int length) {
1130 wrapped.skipBytes(length);
1131 return this;
1132 }
1133
1134 @Override
1135 public CompositeByteBuf writeBoolean(boolean value) {
1136 wrapped.writeBoolean(value);
1137 return this;
1138 }
1139
1140 @Override
1141 public CompositeByteBuf writeByte(int value) {
1142 wrapped.writeByte(value);
1143 return this;
1144 }
1145
1146 @Override
1147 public CompositeByteBuf writeShort(int value) {
1148 wrapped.writeShort(value);
1149 return this;
1150 }
1151
1152 @Override
1153 public CompositeByteBuf writeMedium(int value) {
1154 wrapped.writeMedium(value);
1155 return this;
1156 }
1157
1158 @Override
1159 public CompositeByteBuf writeInt(int value) {
1160 wrapped.writeInt(value);
1161 return this;
1162 }
1163
1164 @Override
1165 public CompositeByteBuf writeLong(long value) {
1166 wrapped.writeLong(value);
1167 return this;
1168 }
1169
1170 @Override
1171 public CompositeByteBuf writeChar(int value) {
1172 wrapped.writeChar(value);
1173 return this;
1174 }
1175
1176 @Override
1177 public CompositeByteBuf writeFloat(float value) {
1178 wrapped.writeFloat(value);
1179 return this;
1180 }
1181
1182 @Override
1183 public CompositeByteBuf writeDouble(double value) {
1184 wrapped.writeDouble(value);
1185 return this;
1186 }
1187
1188 @Override
1189 public CompositeByteBuf writeBytes(ByteBuf src) {
1190 wrapped.writeBytes(src);
1191 return this;
1192 }
1193
1194 @Override
1195 public CompositeByteBuf writeBytes(ByteBuf src, int length) {
1196 wrapped.writeBytes(src, length);
1197 return this;
1198 }
1199
1200 @Override
1201 public CompositeByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
1202 wrapped.writeBytes(src, srcIndex, length);
1203 return this;
1204 }
1205
1206 @Override
1207 public CompositeByteBuf writeBytes(byte[] src) {
1208 wrapped.writeBytes(src);
1209 return this;
1210 }
1211
1212 @Override
1213 public CompositeByteBuf writeBytes(byte[] src, int srcIndex, int length) {
1214 wrapped.writeBytes(src, srcIndex, length);
1215 return this;
1216 }
1217
1218 @Override
1219 public CompositeByteBuf writeBytes(ByteBuffer src) {
1220 wrapped.writeBytes(src);
1221 return this;
1222 }
1223
1224 @Override
1225 public CompositeByteBuf writeZero(int length) {
1226 wrapped.writeZero(length);
1227 return this;
1228 }
1229
1230 @Override
1231 public CompositeByteBuf retain(int increment) {
1232 wrapped.retain(increment);
1233 return this;
1234 }
1235
1236 @Override
1237 public CompositeByteBuf retain() {
1238 wrapped.retain();
1239 return this;
1240 }
1241
1242 @Override
1243 public CompositeByteBuf touch() {
1244 wrapped.touch();
1245 return this;
1246 }
1247
1248 @Override
1249 public CompositeByteBuf touch(Object hint) {
1250 wrapped.touch(hint);
1251 return this;
1252 }
1253
1254 @Override
1255 public ByteBuffer[] nioBuffers() {
1256 return wrapped.nioBuffers();
1257 }
1258
1259 @Override
1260 public CompositeByteBuf discardSomeReadBytes() {
1261 wrapped.discardSomeReadBytes();
1262 return this;
1263 }
1264
1265 @Override
1266 public final void deallocate() {
1267 wrapped.deallocate();
1268 }
1269
1270 @Override
1271 public final ByteBuf unwrap() {
1272 return wrapped;
1273 }
1274 }