001 /* 002 * Copyright 2009 Red Hat, Inc. 003 * Red Hat licenses this file to you under the Apache License, version 004 * 2.0 (the "License"); you may not use this file except in compliance 005 * with the License. You may obtain a copy of the License at 006 * http://www.apache.org/licenses/LICENSE-2.0 007 * Unless required by applicable law or agreed to in writing, software 008 * distributed under the License is distributed on an "AS IS" BASIS, 009 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 010 * implied. See the License for the specific language governing 011 * permissions and limitations under the License. 012 */ 013 014 package org.hornetq.api.core; 015 016 import java.nio.ByteBuffer; 017 018 import org.jboss.netty.buffer.ChannelBuffer; 019 020 /** 021 * 022 * A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. 023 * 024 * Much of it derived from Netty ChannelBuffer by Trustin Lee 025 * 026 * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> 027 * 028 * @see HornetQBuffers 029 * 030 */ 031 public interface HornetQBuffer 032 { 033 /** 034 * Returns the underlying Netty's ChannelBuffer 035 * 036 * @return the underlying Netty's ChannelBuffer 037 */ 038 ChannelBuffer channelBuffer(); 039 040 /** 041 * Returns the number of bytes this buffer can contain. 042 */ 043 int capacity(); 044 045 /** 046 * Returns the {@code readerIndex} of this buffer. 047 */ 048 int readerIndex(); 049 050 /** 051 * Sets the {@code readerIndex} of this buffer. 052 * 053 * @throws IndexOutOfBoundsException 054 * if the specified {@code readerIndex} is 055 * less than {@code 0} or 056 * greater than {@code this.writerIndex} 057 */ 058 void readerIndex(int readerIndex); 059 060 /** 061 * Returns the {@code writerIndex} of this buffer. 062 */ 063 int writerIndex(); 064 065 /** 066 * Sets the {@code writerIndex} of this buffer. 067 * 068 * @throws IndexOutOfBoundsException 069 * if the specified {@code writerIndex} is 070 * less than {@code this.readerIndex} or 071 * greater than {@code this.capacity} 072 */ 073 void writerIndex(int writerIndex); 074 075 /** 076 * Sets the {@code readerIndex} and {@code writerIndex} of this buffer 077 * in one shot. This method is useful when you have to worry about the 078 * invocation order of {@link #readerIndex(int)} and {@link #writerIndex(int)} 079 * methods. For example, the following code will fail: 080 * 081 * <pre> 082 * // Create a buffer whose readerIndex, writerIndex and capacity are 083 * // 0, 0 and 8 respectively. 084 * ChannelBuffer buf = ChannelBuffers.buffer(8); 085 * 086 * // IndexOutOfBoundsException is thrown because the specified 087 * // readerIndex (2) cannot be greater than the current writerIndex (0). 088 * buf.readerIndex(2); 089 * buf.writerIndex(4); 090 * </pre> 091 * 092 * The following code will also fail: 093 * 094 * <pre> 095 * // Create a buffer whose readerIndex, writerIndex and capacity are 096 * // 0, 8 and 8 respectively. 097 * ChannelBuffer buf = ChannelBuffers.wrappedBuffer(new byte[8]); 098 * 099 * // readerIndex becomes 8. 100 * buf.readLong(); 101 * 102 * // IndexOutOfBoundsException is thrown because the specified 103 * // writerIndex (4) cannot be less than the current readerIndex (8). 104 * buf.writerIndex(4); 105 * buf.readerIndex(2); 106 * </pre> 107 * 108 * By contrast, {@link #setIndex(int, int)} guarantees that it never 109 * throws an {@link IndexOutOfBoundsException} as long as the specified 110 * indexes meet basic constraints, regardless what the current index 111 * values of the buffer are: 112 * 113 * <pre> 114 * // No matter what the current state of the buffer is, the following 115 * // call always succeeds as long as the capacity of the buffer is not 116 * // less than 4. 117 * buf.setIndex(2, 4); 118 * </pre> 119 * 120 * @throws IndexOutOfBoundsException 121 * if the specified {@code readerIndex} is less than 0, 122 * if the specified {@code writerIndex} is less than the specified 123 * {@code readerIndex} or if the specified {@code writerIndex} is 124 * greater than {@code this.capacity} 125 */ 126 void setIndex(int readerIndex, int writerIndex); 127 128 /** 129 * Returns the number of readable bytes which is equal to 130 * {@code (this.writerIndex - this.readerIndex)}. 131 */ 132 int readableBytes(); 133 134 /** 135 * Returns the number of writable bytes which is equal to 136 * {@code (this.capacity - this.writerIndex)}. 137 */ 138 int writableBytes(); 139 140 /** 141 * Returns {@code true} 142 * if and only if {@code (this.writerIndex - this.readerIndex)} is greater 143 * than {@code 0}. 144 */ 145 boolean readable(); 146 147 /** 148 * Returns {@code true} 149 * if and only if {@code (this.capacity - this.writerIndex)} is greater 150 * than {@code 0}. 151 */ 152 boolean writable(); 153 154 /** 155 * Sets the {@code readerIndex} and {@code writerIndex} of this buffer to 156 * {@code 0}. 157 * This method is identical to {@link #setIndex(int, int) setIndex(0, 0)}. 158 * <p> 159 * Please note that the behavior of this method is different 160 * from that of NIO buffer, which sets the {@code limit} to 161 * the {@code capacity} of the buffer. 162 */ 163 void clear(); 164 165 /** 166 * Marks the current {@code readerIndex} in this buffer. You can 167 * reposition the current {@code readerIndex} to the marked 168 * {@code readerIndex} by calling {@link #resetReaderIndex()}. 169 * The initial value of the marked {@code readerIndex} is {@code 0}. 170 */ 171 void markReaderIndex(); 172 173 /** 174 * Repositions the current {@code readerIndex} to the marked 175 * {@code readerIndex} in this buffer. 176 * 177 * @throws IndexOutOfBoundsException 178 * if the current {@code writerIndex} is less than the marked 179 * {@code readerIndex} 180 */ 181 void resetReaderIndex(); 182 183 /** 184 * Marks the current {@code writerIndex} in this buffer. You can 185 * reposition the current {@code writerIndex} to the marked 186 * {@code writerIndex} by calling {@link #resetWriterIndex()}. 187 * The initial value of the marked {@code writerIndex} is {@code 0}. 188 */ 189 void markWriterIndex(); 190 191 /** 192 * Repositions the current {@code writerIndex} to the marked 193 * {@code writerIndex} in this buffer. 194 * 195 * @throws IndexOutOfBoundsException 196 * if the current {@code readerIndex} is greater than the marked 197 * {@code writerIndex} 198 */ 199 void resetWriterIndex(); 200 201 /** 202 * Discards the bytes between the 0th index and {@code readerIndex}. 203 * It moves the bytes between {@code readerIndex} and {@code writerIndex} 204 * to the 0th index, and sets {@code readerIndex} and {@code writerIndex} 205 * to {@code 0} and {@code oldWriterIndex - oldReaderIndex} respectively. 206 * <p> 207 * Please refer to the class documentation for more detailed explanation. 208 */ 209 void discardReadBytes(); 210 211 /** 212 * Gets a byte at the specified absolute {@code index} in this buffer. 213 * This method does not modify {@code readerIndex} or {@code writerIndex} of 214 * this buffer. 215 * 216 * @throws IndexOutOfBoundsException 217 * if the specified {@code index} is less than {@code 0} or 218 * {@code index + 1} is greater than {@code this.capacity} 219 */ 220 byte getByte(int index); 221 222 /** 223 * Gets an unsigned byte at the specified absolute {@code index} in this 224 * buffer. This method does not modify {@code readerIndex} or 225 * {@code writerIndex} of this buffer. 226 * 227 * @throws IndexOutOfBoundsException 228 * if the specified {@code index} is less than {@code 0} or 229 * {@code index + 1} is greater than {@code this.capacity} 230 */ 231 short getUnsignedByte(int index); 232 233 /** 234 * Gets a 16-bit short integer at the specified absolute {@code index} in 235 * this buffer. This method does not modify {@code readerIndex} or 236 * {@code writerIndex} of this buffer. 237 * 238 * @throws IndexOutOfBoundsException 239 * if the specified {@code index} is less than {@code 0} or 240 * {@code index + 2} is greater than {@code this.capacity} 241 */ 242 short getShort(int index); 243 244 /** 245 * Gets an unsigned 16-bit short integer at the specified absolute 246 * {@code index} in this buffer. This method does not modify 247 * {@code readerIndex} or {@code writerIndex} of this buffer. 248 * 249 * @throws IndexOutOfBoundsException 250 * if the specified {@code index} is less than {@code 0} or 251 * {@code index + 2} is greater than {@code this.capacity} 252 */ 253 int getUnsignedShort(int index); 254 255 /** 256 * Gets a 32-bit integer at the specified absolute {@code index} in 257 * this buffer. This method does not modify {@code readerIndex} or 258 * {@code writerIndex} of this buffer. 259 * 260 * @throws IndexOutOfBoundsException 261 * if the specified {@code index} is less than {@code 0} or 262 * {@code index + 4} is greater than {@code this.capacity} 263 */ 264 int getInt(int index); 265 266 /** 267 * Gets an unsigned 32-bit integer at the specified absolute {@code index} 268 * in this buffer. This method does not modify {@code readerIndex} or 269 * {@code writerIndex} of this buffer. 270 * 271 * @throws IndexOutOfBoundsException 272 * if the specified {@code index} is less than {@code 0} or 273 * {@code index + 4} is greater than {@code this.capacity} 274 */ 275 long getUnsignedInt(int index); 276 277 /** 278 * Gets a 64-bit long integer at the specified absolute {@code index} in 279 * this buffer. This method does not modify {@code readerIndex} or 280 * {@code writerIndex} of this buffer. 281 * 282 * @throws IndexOutOfBoundsException 283 * if the specified {@code index} is less than {@code 0} or 284 * {@code index + 8} is greater than {@code this.capacity} 285 */ 286 long getLong(int index); 287 288 /** 289 * Transfers this buffer's data to the specified destination starting at 290 * the specified absolute {@code index} until the destination becomes 291 * non-writable. This method is basically same with 292 * {@link #getBytes(int, HornetQBuffer, int, int)}, except that this 293 * method increases the {@code writerIndex} of the destination by the 294 * number of the transferred bytes while 295 * {@link #getBytes(int, HornetQBuffer, int, int)} does not. 296 * This method does not modify {@code readerIndex} or {@code writerIndex} of 297 * the source buffer (i.e. {@code this}). 298 * 299 * @throws IndexOutOfBoundsException 300 * if the specified {@code index} is less than {@code 0} or 301 * if {@code index + dst.writableBytes} is greater than 302 * {@code this.capacity} 303 */ 304 void getBytes(int index, HornetQBuffer dst); 305 306 /** 307 * Transfers this buffer's data to the specified destination starting at 308 * the specified absolute {@code index}. This method is basically same 309 * with {@link #getBytes(int, HornetQBuffer, int, int)}, except that this 310 * method increases the {@code writerIndex} of the destination by the 311 * number of the transferred bytes while 312 * {@link #getBytes(int, HornetQBuffer, int, int)} does not. 313 * This method does not modify {@code readerIndex} or {@code writerIndex} of 314 * the source buffer (i.e. {@code this}). 315 * 316 * @param length the number of bytes to transfer 317 * 318 * @throws IndexOutOfBoundsException 319 * if the specified {@code index} is less than {@code 0}, 320 * if {@code index + length} is greater than 321 * {@code this.capacity}, or 322 * if {@code length} is greater than {@code dst.writableBytes} 323 */ 324 void getBytes(int index, HornetQBuffer dst, int length); 325 326 /** 327 * Transfers this buffer's data to the specified destination starting at 328 * the specified absolute {@code index}. 329 * This method does not modify {@code readerIndex} or {@code writerIndex} 330 * of both the source (i.e. {@code this}) and the destination. 331 * 332 * @param dstIndex the first index of the destination 333 * @param length the number of bytes to transfer 334 * 335 * @throws IndexOutOfBoundsException 336 * if the specified {@code index} is less than {@code 0}, 337 * if the specified {@code dstIndex} is less than {@code 0}, 338 * if {@code index + length} is greater than 339 * {@code this.capacity}, or 340 * if {@code dstIndex + length} is greater than 341 * {@code dst.capacity} 342 */ 343 void getBytes(int index, HornetQBuffer dst, int dstIndex, int length); 344 345 /** 346 * Transfers this buffer's data to the specified destination starting at 347 * the specified absolute {@code index}. 348 * This method does not modify {@code readerIndex} or {@code writerIndex} of 349 * this buffer 350 * 351 * @throws IndexOutOfBoundsException 352 * if the specified {@code index} is less than {@code 0} or 353 * if {@code index + dst.length} is greater than 354 * {@code this.capacity} 355 */ 356 void getBytes(int index, byte[] dst); 357 358 /** 359 * Transfers this buffer's data to the specified destination starting at 360 * the specified absolute {@code index}. 361 * This method does not modify {@code readerIndex} or {@code writerIndex} 362 * of this buffer. 363 * 364 * @param dstIndex the first index of the destination 365 * @param length the number of bytes to transfer 366 * 367 * @throws IndexOutOfBoundsException 368 * if the specified {@code index} is less than {@code 0}, 369 * if the specified {@code dstIndex} is less than {@code 0}, 370 * if {@code index + length} is greater than 371 * {@code this.capacity}, or 372 * if {@code dstIndex + length} is greater than 373 * {@code dst.length} 374 */ 375 void getBytes(int index, byte[] dst, int dstIndex, int length); 376 377 /** 378 * Transfers this buffer's data to the specified destination starting at 379 * the specified absolute {@code index} until the destination's position 380 * reaches its limit. 381 * This method does not modify {@code readerIndex} or {@code writerIndex} of 382 * this buffer while the destination's {@code position} will be increased. 383 * 384 * @throws IndexOutOfBoundsException 385 * if the specified {@code index} is less than {@code 0} or 386 * if {@code index + dst.remaining()} is greater than 387 * {@code this.capacity} 388 */ 389 void getBytes(int index, ByteBuffer dst); 390 391 /** 392 * Gets a char at the specified absolute {@code index} in 393 * this buffer. This method does not modify {@code readerIndex} or 394 * {@code writerIndex} of this buffer. 395 * 396 * @throws IndexOutOfBoundsException 397 * if the specified {@code index} is less than {@code 0} or 398 * {@code index + 2} is greater than {@code this.capacity} 399 */ 400 char getChar(int index); 401 402 /** 403 * Gets a float at the specified absolute {@code index} in 404 * this buffer. This method does not modify {@code readerIndex} or 405 * {@code writerIndex} of this buffer. 406 * 407 * @throws IndexOutOfBoundsException 408 * if the specified {@code index} is less than {@code 0} or 409 * {@code index + 4} is greater than {@code this.capacity} 410 */ 411 float getFloat(int index); 412 413 /** 414 * Gets a double at the specified absolute {@code index} in 415 * this buffer. This method does not modify {@code readerIndex} or 416 * {@code writerIndex} of this buffer. 417 * 418 * @throws IndexOutOfBoundsException 419 * if the specified {@code index} is less than {@code 0} or 420 * {@code index + 8} is greater than {@code this.capacity} 421 */ 422 double getDouble(int index); 423 424 /** 425 * Sets the specified byte at the specified absolute {@code index} in this 426 * buffer. 427 * This method does not modify {@code readerIndex} or {@code writerIndex} of 428 * this buffer. 429 * 430 * @throws IndexOutOfBoundsException 431 * if the specified {@code index} is less than {@code 0} or 432 * {@code index + 1} is greater than {@code this.capacity} 433 */ 434 void setByte(int index, byte value); 435 436 /** 437 * Sets the specified 16-bit short integer at the specified absolute 438 * {@code index} in this buffer. 439 * This method does not modify {@code readerIndex} or {@code writerIndex} of 440 * this buffer. 441 * 442 * @throws IndexOutOfBoundsException 443 * if the specified {@code index} is less than {@code 0} or 444 * {@code index + 2} is greater than {@code this.capacity} 445 */ 446 void setShort(int index, short value); 447 448 /** 449 * Sets the specified 32-bit integer at the specified absolute 450 * {@code index} in this buffer. 451 * This method does not modify {@code readerIndex} or {@code writerIndex} of 452 * this buffer. 453 * 454 * @throws IndexOutOfBoundsException 455 * if the specified {@code index} is less than {@code 0} or 456 * {@code index + 4} is greater than {@code this.capacity} 457 */ 458 void setInt(int index, int value); 459 460 /** 461 * Sets the specified 64-bit long integer at the specified absolute 462 * {@code index} in this buffer. 463 * This method does not modify {@code readerIndex} or {@code writerIndex} of 464 * this buffer. 465 * 466 * @throws IndexOutOfBoundsException 467 * if the specified {@code index} is less than {@code 0} or 468 * {@code index + 8} is greater than {@code this.capacity} 469 */ 470 void setLong(int index, long value); 471 472 /** 473 * Transfers the specified source buffer's data to this buffer starting at 474 * the specified absolute {@code index} until the destination becomes 475 * unreadable. This method is basically same with 476 * {@link #setBytes(int, HornetQBuffer, int, int)}, except that this 477 * method increases the {@code readerIndex} of the source buffer by 478 * the number of the transferred bytes while 479 * {@link #getBytes(int, HornetQBuffer, int, int)} does not. 480 * This method does not modify {@code readerIndex} or {@code writerIndex} of 481 * the source buffer (i.e. {@code this}). 482 * 483 * @throws IndexOutOfBoundsException 484 * if the specified {@code index} is less than {@code 0} or 485 * if {@code index + src.readableBytes} is greater than 486 * {@code this.capacity} 487 */ 488 void setBytes(int index, HornetQBuffer src); 489 490 /** 491 * Transfers the specified source buffer's data to this buffer starting at 492 * the specified absolute {@code index}. This method is basically same 493 * with {@link #setBytes(int, HornetQBuffer, int, int)}, except that this 494 * method increases the {@code readerIndex} of the source buffer by 495 * the number of the transferred bytes while 496 * {@link #getBytes(int, HornetQBuffer, int, int)} does not. 497 * This method does not modify {@code readerIndex} or {@code writerIndex} of 498 * the source buffer (i.e. {@code this}). 499 * 500 * @param length the number of bytes to transfer 501 * 502 * @throws IndexOutOfBoundsException 503 * if the specified {@code index} is less than {@code 0}, 504 * if {@code index + length} is greater than 505 * {@code this.capacity}, or 506 * if {@code length} is greater than {@code src.readableBytes} 507 */ 508 void setBytes(int index, HornetQBuffer src, int length); 509 510 /** 511 * Transfers the specified source buffer's data to this buffer starting at 512 * the specified absolute {@code index}. 513 * This method does not modify {@code readerIndex} or {@code writerIndex} 514 * of both the source (i.e. {@code this}) and the destination. 515 * 516 * @param srcIndex the first index of the source 517 * @param length the number of bytes to transfer 518 * 519 * @throws IndexOutOfBoundsException 520 * if the specified {@code index} is less than {@code 0}, 521 * if the specified {@code srcIndex} is less than {@code 0}, 522 * if {@code index + length} is greater than 523 * {@code this.capacity}, or 524 * if {@code srcIndex + length} is greater than 525 * {@code src.capacity} 526 */ 527 void setBytes(int index, HornetQBuffer src, int srcIndex, int length); 528 529 /** 530 * Transfers the specified source array's data to this buffer starting at 531 * the specified absolute {@code index}. 532 * This method does not modify {@code readerIndex} or {@code writerIndex} of 533 * this buffer. 534 * 535 * @throws IndexOutOfBoundsException 536 * if the specified {@code index} is less than {@code 0} or 537 * if {@code index + src.length} is greater than 538 * {@code this.capacity} 539 */ 540 void setBytes(int index, byte[] src); 541 542 /** 543 * Transfers the specified source array's data to this buffer starting at 544 * the specified absolute {@code index}. 545 * This method does not modify {@code readerIndex} or {@code writerIndex} of 546 * this buffer. 547 * 548 * @throws IndexOutOfBoundsException 549 * if the specified {@code index} is less than {@code 0}, 550 * if the specified {@code srcIndex} is less than {@code 0}, 551 * if {@code index + length} is greater than 552 * {@code this.capacity}, or 553 * if {@code srcIndex + length} is greater than {@code src.length} 554 */ 555 void setBytes(int index, byte[] src, int srcIndex, int length); 556 557 /** 558 * Transfers the specified source buffer's data to this buffer starting at 559 * the specified absolute {@code index} until the source buffer's position 560 * reaches its limit. 561 * This method does not modify {@code readerIndex} or {@code writerIndex} of 562 * this buffer. 563 * 564 * @throws IndexOutOfBoundsException 565 * if the specified {@code index} is less than {@code 0} or 566 * if {@code index + src.remaining()} is greater than 567 * {@code this.capacity} 568 */ 569 void setBytes(int index, ByteBuffer src); 570 571 /** 572 * Sets the specified char at the specified absolute 573 * {@code index} in this buffer. 574 * This method does not modify {@code readerIndex} or {@code writerIndex} of 575 * this buffer. 576 * 577 * @throws IndexOutOfBoundsException 578 * if the specified {@code index} is less than {@code 0} or 579 * {@code index + 2} is greater than {@code this.capacity} 580 */ 581 void setChar(int index, char value); 582 583 /** 584 * Sets the specified float at the specified absolute 585 * {@code index} in this buffer. 586 * This method does not modify {@code readerIndex} or {@code writerIndex} of 587 * this buffer. 588 * 589 * @throws IndexOutOfBoundsException 590 * if the specified {@code index} is less than {@code 0} or 591 * {@code index + 4} is greater than {@code this.capacity} 592 */ 593 void setFloat(int index, float value); 594 595 /** 596 * Sets the specified double at the specified absolute 597 * {@code index} in this buffer. 598 * This method does not modify {@code readerIndex} or {@code writerIndex} of 599 * this buffer. 600 * 601 * @throws IndexOutOfBoundsException 602 * if the specified {@code index} is less than {@code 0} or 603 * {@code index + 8} is greater than {@code this.capacity} 604 */ 605 void setDouble(int index, double value); 606 607 /** 608 * Gets a byte at the current {@code readerIndex} and increases 609 * the {@code readerIndex} by {@code 1} in this buffer. 610 * 611 * @throws IndexOutOfBoundsException 612 * if {@code this.readableBytes} is less than {@code 1} 613 */ 614 byte readByte(); 615 616 /** 617 * Gets an unsigned byte at the current {@code readerIndex} and increases 618 * the {@code readerIndex} by {@code 1} in this buffer. 619 * 620 * @throws IndexOutOfBoundsException 621 * if {@code this.readableBytes} is less than {@code 1} 622 */ 623 short readUnsignedByte(); 624 625 /** 626 * Gets a 16-bit short integer at the current {@code readerIndex} 627 * and increases the {@code readerIndex} by {@code 2} in this buffer. 628 * 629 * @throws IndexOutOfBoundsException 630 * if {@code this.readableBytes} is less than {@code 2} 631 */ 632 short readShort(); 633 634 /** 635 * Gets an unsigned 16-bit short integer at the current {@code readerIndex} 636 * and increases the {@code readerIndex} by {@code 2} in this buffer. 637 * 638 * @throws IndexOutOfBoundsException 639 * if {@code this.readableBytes} is less than {@code 2} 640 */ 641 int readUnsignedShort(); 642 643 /** 644 * Gets a 32-bit integer at the current {@code readerIndex} 645 * and increases the {@code readerIndex} by {@code 4} in this buffer. 646 * 647 * @throws IndexOutOfBoundsException 648 * if {@code this.readableBytes} is less than {@code 4} 649 */ 650 int readInt(); 651 652 /** 653 * Gets an unsigned 32-bit integer at the current {@code readerIndex} 654 * and increases the {@code readerIndex} by {@code 4} in this buffer. 655 * 656 * @throws IndexOutOfBoundsException 657 * if {@code this.readableBytes} is less than {@code 4} 658 */ 659 long readUnsignedInt(); 660 661 /** 662 * Gets a 64-bit integer at the current {@code readerIndex} 663 * and increases the {@code readerIndex} by {@code 8} in this buffer. 664 * 665 * @throws IndexOutOfBoundsException 666 * if {@code this.readableBytes} is less than {@code 8} 667 */ 668 long readLong(); 669 670 /** 671 * Gets a char at the current {@code readerIndex} 672 * and increases the {@code readerIndex} by {@code 2} in this buffer. 673 * 674 * @throws IndexOutOfBoundsException 675 * if {@code this.readableBytes} is less than {@code 2} 676 */ 677 char readChar(); 678 679 /** 680 * Gets a float at the current {@code readerIndex} 681 * and increases the {@code readerIndex} by {@code 4} in this buffer. 682 * 683 * @throws IndexOutOfBoundsException 684 * if {@code this.readableBytes} is less than {@code 4} 685 */ 686 float readFloat(); 687 688 /** 689 * Gets a double at the current {@code readerIndex} 690 * and increases the {@code readerIndex} by {@code 8} in this buffer. 691 * 692 * @throws IndexOutOfBoundsException 693 * if {@code this.readableBytes} is less than {@code 8} 694 */ 695 double readDouble(); 696 697 /** 698 * Gets a boolean at the current {@code readerIndex} 699 * and increases the {@code readerIndex} by {@code 1} in this buffer. 700 * 701 * @throws IndexOutOfBoundsException 702 * if {@code this.readableBytes} is less than {@code 1} 703 */ 704 boolean readBoolean(); 705 706 /** 707 * Gets a SimpleString (potentially {@code null}) at the current {@code readerIndex} 708 */ 709 SimpleString readNullableSimpleString(); 710 711 /** 712 * Gets a String (potentially {@code null}) at the current {@code readerIndex} 713 */ 714 String readNullableString(); 715 716 /** 717 * Gets a non-null SimpleString at the current {@code readerIndex} 718 */ 719 SimpleString readSimpleString(); 720 721 /** 722 * Gets a non-null String at the current {@code readerIndex} 723 */ 724 String readString(); 725 726 /** 727 * Gets a UTF-8 String at the current {@code readerIndex} 728 */ 729 String readUTF(); 730 731 /** 732 * Transfers this buffer's data to a newly created buffer starting at 733 * the current {@code readerIndex} and increases the {@code readerIndex} 734 * by the number of the transferred bytes (= {@code length}). 735 * The returned buffer's {@code readerIndex} and {@code writerIndex} are 736 * {@code 0} and {@code length} respectively. 737 * 738 * @param length the number of bytes to transfer 739 * 740 * @return the newly created buffer which contains the transferred bytes 741 * 742 * @throws IndexOutOfBoundsException 743 * if {@code length} is greater than {@code this.readableBytes} 744 */ 745 HornetQBuffer readBytes(int length); 746 747 /** 748 * Returns a new slice of this buffer's sub-region starting at the current 749 * {@code readerIndex} and increases the {@code readerIndex} by the size 750 * of the new slice (= {@code length}). 751 * 752 * @param length the size of the new slice 753 * 754 * @return the newly created slice 755 * 756 * @throws IndexOutOfBoundsException 757 * if {@code length} is greater than {@code this.readableBytes} 758 */ 759 HornetQBuffer readSlice(int length); 760 761 /** 762 * Transfers this buffer's data to the specified destination starting at 763 * the current {@code readerIndex} until the destination becomes 764 * non-writable, and increases the {@code readerIndex} by the number of the 765 * transferred bytes. This method is basically same with 766 * {@link #readBytes(HornetQBuffer, int, int)}, except that this method 767 * increases the {@code writerIndex} of the destination by the number of 768 * the transferred bytes while {@link #readBytes(HornetQBuffer, int, int)} 769 * does not. 770 * 771 * @throws IndexOutOfBoundsException 772 * if {@code dst.writableBytes} is greater than 773 * {@code this.readableBytes} 774 */ 775 void readBytes(HornetQBuffer dst); 776 777 /** 778 * Transfers this buffer's data to the specified destination starting at 779 * the current {@code readerIndex} and increases the {@code readerIndex} 780 * by the number of the transferred bytes (= {@code length}). This method 781 * is basically same with {@link #readBytes(HornetQBuffer, int, int)}, 782 * except that this method increases the {@code writerIndex} of the 783 * destination by the number of the transferred bytes (= {@code length}) 784 * while {@link #readBytes(HornetQBuffer, int, int)} does not. 785 * 786 * @throws IndexOutOfBoundsException 787 * if {@code length} is greater than {@code this.readableBytes} or 788 * if {@code length} is greater than {@code dst.writableBytes} 789 */ 790 void readBytes(HornetQBuffer dst, int length); 791 792 /** 793 * Transfers this buffer's data to the specified destination starting at 794 * the current {@code readerIndex} and increases the {@code readerIndex} 795 * by the number of the transferred bytes (= {@code length}). 796 * 797 * @param dstIndex the first index of the destination 798 * @param length the number of bytes to transfer 799 * 800 * @throws IndexOutOfBoundsException 801 * if the specified {@code dstIndex} is less than {@code 0}, 802 * if {@code length} is greater than {@code this.readableBytes}, or 803 * if {@code dstIndex + length} is greater than 804 * {@code dst.capacity} 805 */ 806 void readBytes(HornetQBuffer dst, int dstIndex, int length); 807 808 /** 809 * Transfers this buffer's data to the specified destination starting at 810 * the current {@code readerIndex} and increases the {@code readerIndex} 811 * by the number of the transferred bytes (= {@code dst.length}). 812 * 813 * @throws IndexOutOfBoundsException 814 * if {@code dst.length} is greater than {@code this.readableBytes} 815 */ 816 void readBytes(byte[] dst); 817 818 /** 819 * Transfers this buffer's data to the specified destination starting at 820 * the current {@code readerIndex} and increases the {@code readerIndex} 821 * by the number of the transferred bytes (= {@code length}). 822 * 823 * @param dstIndex the first index of the destination 824 * @param length the number of bytes to transfer 825 * 826 * @throws IndexOutOfBoundsException 827 * if the specified {@code dstIndex} is less than {@code 0}, 828 * if {@code length} is greater than {@code this.readableBytes}, or 829 * if {@code dstIndex + length} is greater than {@code dst.length} 830 */ 831 void readBytes(byte[] dst, int dstIndex, int length); 832 833 /** 834 * Transfers this buffer's data to the specified destination starting at 835 * the current {@code readerIndex} until the destination's position 836 * reaches its limit, and increases the {@code readerIndex} by the 837 * number of the transferred bytes. 838 * 839 * @throws IndexOutOfBoundsException 840 * if {@code dst.remaining()} is greater than 841 * {@code this.readableBytes} 842 */ 843 void readBytes(ByteBuffer dst); 844 845 /** 846 * Increases the current {@code readerIndex} by the specified 847 * {@code length} in this buffer. 848 * 849 * @throws IndexOutOfBoundsException 850 * if {@code length} is greater than {@code this.readableBytes} 851 */ 852 void skipBytes(int length); 853 854 /** 855 * Sets the specified byte at the current {@code writerIndex} 856 * and increases the {@code writerIndex} by {@code 1} in this buffer. 857 * 858 * @throws IndexOutOfBoundsException 859 * if {@code this.writableBytes} is less than {@code 1} 860 */ 861 void writeByte(byte value); 862 863 /** 864 * Sets the specified 16-bit short integer at the current 865 * {@code writerIndex} and increases the {@code writerIndex} by {@code 2} 866 * in this buffer. 867 * 868 * @throws IndexOutOfBoundsException 869 * if {@code this.writableBytes} is less than {@code 2} 870 */ 871 void writeShort(short value); 872 873 /** 874 * Sets the specified 32-bit integer at the current {@code writerIndex} 875 * and increases the {@code writerIndex} by {@code 4} in this buffer. 876 * 877 * @throws IndexOutOfBoundsException 878 * if {@code this.writableBytes} is less than {@code 4} 879 */ 880 void writeInt(int value); 881 882 /** 883 * Sets the specified 64-bit long integer at the current 884 * {@code writerIndex} and increases the {@code writerIndex} by {@code 8} 885 * in this buffer. 886 * 887 * @throws IndexOutOfBoundsException 888 * if {@code this.writableBytes} is less than {@code 8} 889 */ 890 void writeLong(long value); 891 892 /** 893 * Sets the specified char at the current {@code writerIndex} 894 * and increases the {@code writerIndex} by {@code 2} in this buffer. 895 * 896 * @throws IndexOutOfBoundsException 897 * if {@code this.writableBytes} is less than {@code 2} 898 */ 899 void writeChar(char chr); 900 901 /** 902 * Sets the specified float at the current {@code writerIndex} 903 * and increases the {@code writerIndex} by {@code 4} in this buffer. 904 * 905 * @throws IndexOutOfBoundsException 906 * if {@code this.writableBytes} is less than {@code 4} 907 */ 908 void writeFloat(float value); 909 910 /** 911 * Sets the specified double at the current {@code writerIndex} 912 * and increases the {@code writerIndex} by {@code 8} in this buffer. 913 * 914 * @throws IndexOutOfBoundsException 915 * if {@code this.writableBytes} is less than {@code 8} 916 */ 917 void writeDouble(double value); 918 919 /** 920 * Sets the specified boolean at the current {@code writerIndex} 921 */ 922 void writeBoolean(boolean val); 923 924 /** 925 * Sets the specified SimpleString (potentially {@code null}) at the current {@code writerIndex} 926 */ 927 void writeNullableSimpleString(SimpleString val); 928 929 /** 930 * Sets the specified String (potentially {@code null}) at the current {@code writerIndex} 931 */ 932 void writeNullableString(String val); 933 934 /** 935 * Sets the specified non-null SimpleString at the current {@code writerIndex} 936 */ 937 void writeSimpleString(SimpleString val); 938 939 /** 940 * Sets the specified non-null String at the current {@code writerIndex} 941 */ 942 void writeString(String val); 943 944 /** 945 * Sets the specified UTF-8 String at the current {@code writerIndex} 946 */ 947 948 void writeUTF(String utf); 949 950 /** 951 * Transfers the specified source buffer's data to this buffer starting at 952 * the current {@code writerIndex} and increases the {@code writerIndex} 953 * by the number of the transferred bytes (= {@code length}). This method 954 * is basically same with {@link #writeBytes(HornetQBuffer, int, int)}, 955 * except that this method increases the {@code readerIndex} of the source 956 * buffer by the number of the transferred bytes (= {@code length}) while 957 * {@link #writeBytes(HornetQBuffer, int, int)} does not. 958 * 959 * @param length the number of bytes to transfer 960 * 961 * @throws IndexOutOfBoundsException 962 * if {@code length} is greater than {@code this.writableBytes} or 963 * if {@code length} is greater then {@code src.readableBytes} 964 */ 965 void writeBytes(HornetQBuffer src, int length); 966 967 /** 968 * Transfers the specified source buffer's data to this buffer starting at 969 * the current {@code writerIndex} and increases the {@code writerIndex} 970 * by the number of the transferred bytes (= {@code length}). 971 * 972 * @param srcIndex the first index of the source 973 * @param length the number of bytes to transfer 974 * 975 * @throws IndexOutOfBoundsException 976 * if the specified {@code srcIndex} is less than {@code 0}, 977 * if {@code srcIndex + length} is greater than 978 * {@code src.capacity}, or 979 * if {@code length} is greater than {@code this.writableBytes} 980 */ 981 void writeBytes(HornetQBuffer src, int srcIndex, int length); 982 983 /** 984 * Transfers the specified source array's data to this buffer starting at 985 * the current {@code writerIndex} and increases the {@code writerIndex} 986 * by the number of the transferred bytes (= {@code src.length}). 987 * 988 * @throws IndexOutOfBoundsException 989 * if {@code src.length} is greater than {@code this.writableBytes} 990 */ 991 void writeBytes(byte[] src); 992 993 /** 994 * Transfers the specified source array's data to this buffer starting at 995 * the current {@code writerIndex} and increases the {@code writerIndex} 996 * by the number of the transferred bytes (= {@code length}). 997 * 998 * @param srcIndex the first index of the source 999 * @param length the number of bytes to transfer 1000 * 1001 * @throws IndexOutOfBoundsException 1002 * if the specified {@code srcIndex} is less than {@code 0}, 1003 * if {@code srcIndex + length} is greater than 1004 * {@code src.length}, or 1005 * if {@code length} is greater than {@code this.writableBytes} 1006 */ 1007 void writeBytes(byte[] src, int srcIndex, int length); 1008 1009 /** 1010 * Transfers the specified source buffer's data to this buffer starting at 1011 * the current {@code writerIndex} until the source buffer's position 1012 * reaches its limit, and increases the {@code writerIndex} by the 1013 * number of the transferred bytes. 1014 * 1015 * @throws IndexOutOfBoundsException 1016 * if {@code src.remaining()} is greater than 1017 * {@code this.writableBytes} 1018 */ 1019 void writeBytes(ByteBuffer src); 1020 1021 /** 1022 * Returns a copy of this buffer's readable bytes. Modifying the content 1023 * of the returned buffer or this buffer does not affect each other at all. 1024 * This method is identical to {@code buf.copy(buf.readerIndex(), buf.readableBytes())}. 1025 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1026 * this buffer. 1027 * 1028 */ 1029 HornetQBuffer copy(); 1030 1031 /** 1032 * Returns a copy of this buffer's sub-region. Modifying the content of 1033 * the returned buffer or this buffer does not affect each other at all. 1034 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1035 * this buffer. 1036 */ 1037 HornetQBuffer copy(int index, int length); 1038 1039 /** 1040 * Returns a slice of this buffer's readable bytes. Modifying the content 1041 * of the returned buffer or this buffer affects each other's content 1042 * while they maintain separate indexes and marks. This method is 1043 * identical to {@code buf.slice(buf.readerIndex(), buf.readableBytes())}. 1044 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1045 * this buffer. 1046 */ 1047 HornetQBuffer slice(); 1048 1049 /** 1050 * Returns a slice of this buffer's sub-region. Modifying the content of 1051 * the returned buffer or this buffer affects each other's content while 1052 * they maintain separate indexes and marks. 1053 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1054 * this buffer. 1055 */ 1056 HornetQBuffer slice(int index, int length); 1057 1058 /** 1059 * Returns a buffer which shares the whole region of this buffer. 1060 * Modifying the content of the returned buffer or this buffer affects 1061 * each other's content while they maintain separate indexes and marks. 1062 * This method is identical to {@code buf.slice(0, buf.capacity())}. 1063 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1064 * this buffer. 1065 */ 1066 HornetQBuffer duplicate(); 1067 1068 /** 1069 * Converts this buffer's readable bytes into a NIO buffer. The returned 1070 * buffer might or might not share the content with this buffer, while 1071 * they have separate indexes and marks. This method is identical to 1072 * {@code buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())}. 1073 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1074 * this buffer. 1075 */ 1076 ByteBuffer toByteBuffer(); 1077 1078 /** 1079 * Converts this buffer's sub-region into a NIO buffer. The returned 1080 * buffer might or might not share the content with this buffer, while 1081 * they have separate indexes and marks. 1082 * This method does not modify {@code readerIndex} or {@code writerIndex} of 1083 * this buffer. 1084 */ 1085 ByteBuffer toByteBuffer(int index, int length); 1086 }