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