View Javadoc

1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License.
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   * A {@link IoBuffer} that wraps a buffer and proxies any operations to it.
41   * <p>
42   * You can think this class like a {@link FilterOutputStream}.  All operations
43   * are proxied by default so that you can extend this class and override existing
44   * operations selectively.  You can introduce new operations, too.
45   *
46   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
47   */
48  public class IoBufferWrapper extends IoBuffer {
49  
50      /**
51       * The buffer proxied by this proxy.
52       */
53      private final IoBuffer buf;
54  
55      /**
56       * Create a new instance.
57       * @param buf the buffer to be proxied
58       */
59      protected IoBufferWrapper(IoBuffer buf) {
60          if (buf == null) {
61              throw new IllegalArgumentException("buf");
62          }
63          this.buf = buf;
64      }
65      
66      /**
67       * Returns the parent buffer that this buffer wrapped.
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 }