View Javadoc
1   /*
2    * Copyright 2016 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    *   https://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 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 }