1 /*
2 * Copyright 2012 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 * http://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 org.jboss.netty.buffer;
17
18 import org.jboss.netty.util.internal.DetectionUtil;
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.GatheringByteChannel;
26 import java.nio.channels.ScatteringByteChannel;
27 import java.util.ArrayList;
28 import java.util.Collections;
29 import java.util.List;
30
31 /**
32 * A virtual buffer which shows multiple buffers as a single merged buffer. It
33 * is recommended to use {@link ChannelBuffers#wrappedBuffer(ChannelBuffer...)}
34 * instead of calling the constructor explicitly.
35 */
36 public class CompositeChannelBuffer extends AbstractChannelBuffer {
37
38 private final ByteOrder order;
39 private ChannelBuffer[] components;
40 private int[] indices;
41 private int lastAccessedComponentId;
42 private final boolean gathering;
43
44 public CompositeChannelBuffer(ByteOrder endianness, List<ChannelBuffer> buffers, boolean gathering) {
45 order = endianness;
46 this.gathering = gathering;
47 setComponents(buffers);
48 }
49
50 /**
51 * Return {@code true} if gathering writes / reads should be used
52 * for this {@link CompositeChannelBuffer}
53 */
54 public boolean useGathering() {
55 return gathering && DetectionUtil.javaVersion() >= 7;
56 }
57
58 /**
59 * Same with {@link #slice(int, int)} except that this method returns a list.
60 */
61 public List<ChannelBuffer> decompose(int index, int length) {
62 if (length == 0) {
63 return Collections.emptyList();
64 }
65
66 if (index + length > capacity()) {
67 throw new IndexOutOfBoundsException("Too many bytes to decompose - Need "
68 + (index + length) + ", capacity is " + capacity());
69 }
70
71 int componentId = componentId(index);
72 List<ChannelBuffer> slice = new ArrayList<ChannelBuffer>(components.length);
73
74 // The first component
75 ChannelBuffer first = components[componentId].duplicate();
76 first.readerIndex(index - indices[componentId]);
77
78 ChannelBuffer buf = first;
79 int bytesToSlice = length;
80 do {
81 int readableBytes = buf.readableBytes();
82 if (bytesToSlice <= readableBytes) {
83 // Last component
84 buf.writerIndex(buf.readerIndex() + bytesToSlice);
85 slice.add(buf);
86 break;
87 } else {
88 // Not the last component
89 slice.add(buf);
90 bytesToSlice -= readableBytes;
91 componentId ++;
92
93 // Fetch the next component.
94 buf = components[componentId].duplicate();
95 }
96 } while (bytesToSlice > 0);
97
98 // Slice all components because only readable bytes are interesting.
99 for (int i = 0; i < slice.size(); i ++) {
100 slice.set(i, slice.get(i).slice());
101 }
102
103 return slice;
104 }
105
106 /**
107 * Setup this ChannelBuffer from the list
108 */
109 private void setComponents(List<ChannelBuffer> newComponents) {
110 assert !newComponents.isEmpty();
111
112 // Clear the cache.
113 lastAccessedComponentId = 0;
114
115 // Build the component array.
116 components = new ChannelBuffer[newComponents.size()];
117 for (int i = 0; i < components.length; i ++) {
118 ChannelBuffer c = newComponents.get(i);
119 if (c.order() != order()) {
120 throw new IllegalArgumentException(
121 "All buffers must have the same endianness.");
122 }
123
124 assert c.readerIndex() == 0;
125 assert c.writerIndex() == c.capacity();
126
127 components[i] = c;
128 }
129
130 // Build the component lookup table.
131 indices = new int[components.length + 1];
132 indices[0] = 0;
133 for (int i = 1; i <= components.length; i ++) {
134 indices[i] = indices[i - 1] + components[i - 1].capacity();
135 }
136
137 // Reset the indexes.
138 setIndex(0, capacity());
139 }
140
141 private CompositeChannelBuffer(CompositeChannelBuffer buffer) {
142 order = buffer.order;
143 gathering = buffer.gathering;
144 components = buffer.components.clone();
145 indices = buffer.indices.clone();
146 setIndex(buffer.readerIndex(), buffer.writerIndex());
147 }
148
149 public ChannelBufferFactory factory() {
150 return HeapChannelBufferFactory.getInstance(order());
151 }
152
153 public ByteOrder order() {
154 return order;
155 }
156
157 public boolean isDirect() {
158 return false;
159 }
160
161 public boolean hasArray() {
162 return false;
163 }
164
165 public byte[] array() {
166 throw new UnsupportedOperationException();
167 }
168
169 public int arrayOffset() {
170 throw new UnsupportedOperationException();
171 }
172
173 public int capacity() {
174 return indices[components.length];
175 }
176
177 public int numComponents() {
178 return components.length;
179 }
180
181 public byte getByte(int index) {
182 int componentId = componentId(index);
183 return components[componentId].getByte(index - indices[componentId]);
184 }
185
186 public short getShort(int index) {
187 int componentId = componentId(index);
188 if (index + 2 <= indices[componentId + 1]) {
189 return components[componentId].getShort(index - indices[componentId]);
190 } else if (order() == ByteOrder.BIG_ENDIAN) {
191 return (short) ((getByte(index) & 0xff) << 8 | getByte(index + 1) & 0xff);
192 } else {
193 return (short) (getByte(index) & 0xff | (getByte(index + 1) & 0xff) << 8);
194 }
195 }
196
197 public int getUnsignedMedium(int index) {
198 int componentId = componentId(index);
199 if (index + 3 <= indices[componentId + 1]) {
200 return components[componentId].getUnsignedMedium(index - indices[componentId]);
201 } else if (order() == ByteOrder.BIG_ENDIAN) {
202 return (getShort(index) & 0xffff) << 8 | getByte(index + 2) & 0xff;
203 } else {
204 return getShort(index) & 0xFFFF | (getByte(index + 2) & 0xFF) << 16;
205 }
206 }
207
208 public int getInt(int index) {
209 int componentId = componentId(index);
210 if (index + 4 <= indices[componentId + 1]) {
211 return components[componentId].getInt(index - indices[componentId]);
212 } else if (order() == ByteOrder.BIG_ENDIAN) {
213 return (getShort(index) & 0xffff) << 16 | getShort(index + 2) & 0xffff;
214 } else {
215 return getShort(index) & 0xFFFF | (getShort(index + 2) & 0xFFFF) << 16;
216 }
217 }
218
219 public long getLong(int index) {
220 int componentId = componentId(index);
221 if (index + 8 <= indices[componentId + 1]) {
222 return components[componentId].getLong(index - indices[componentId]);
223 } else if (order() == ByteOrder.BIG_ENDIAN) {
224 return (getInt(index) & 0xffffffffL) << 32 | getInt(index + 4) & 0xffffffffL;
225 } else {
226 return getInt(index) & 0xFFFFFFFFL | (getInt(index + 4) & 0xFFFFFFFFL) << 32;
227 }
228 }
229
230 public void getBytes(int index, byte[] dst, int dstIndex, int length) {
231 if (index > capacity() - length || dstIndex > dst.length - length) {
232 throw new IndexOutOfBoundsException("Too many bytes to read - Needs "
233 + (index + length) + ", maximum is " + capacity() + " or "
234 + dst.length);
235 }
236 if (index < 0) {
237 throw new IndexOutOfBoundsException("Index must be >= 0");
238 }
239 if (length == 0) {
240 return;
241 }
242
243 int componentId = componentId(index);
244
245 int i = componentId;
246 while (length > 0) {
247 ChannelBuffer s = components[i];
248 int adjustment = indices[i];
249 int localLength = Math.min(length, s.capacity() - (index - adjustment));
250 s.getBytes(index - adjustment, dst, dstIndex, localLength);
251 index += localLength;
252 dstIndex += localLength;
253 length -= localLength;
254 i ++;
255 }
256 }
257
258 public void getBytes(int index, ByteBuffer dst) {
259 int componentId = componentId(index);
260 int limit = dst.limit();
261 int length = dst.remaining();
262 if (index > capacity() - length) {
263 throw new IndexOutOfBoundsException("Too many bytes to be read - Needs "
264 + (index + length) + ", maximum is " + capacity());
265 }
266 if (index < 0) {
267 throw new IndexOutOfBoundsException("Index must be >= 0");
268 }
269 int i = componentId;
270 try {
271 while (length > 0) {
272 ChannelBuffer s = components[i];
273 int adjustment = indices[i];
274 int localLength = Math.min(length, s.capacity() - (index - adjustment));
275 dst.limit(dst.position() + localLength);
276 s.getBytes(index - adjustment, dst);
277 index += localLength;
278 length -= localLength;
279 i ++;
280 }
281 } finally {
282 dst.limit(limit);
283 }
284 }
285
286 public void getBytes(int index, ChannelBuffer dst, int dstIndex, int length) {
287 if (index > capacity() - length || dstIndex > dst.capacity() - length) {
288 throw new IndexOutOfBoundsException("Too many bytes to be read - Needs "
289 + (index + length) + " or " + (dstIndex + length) + ", maximum is "
290 + capacity() + " or " + dst.capacity());
291 }
292 if (index < 0) {
293 throw new IndexOutOfBoundsException("Index must be >= 0");
294 }
295 if (length == 0) {
296 return;
297 }
298 int i = componentId(index);
299 while (length > 0) {
300 ChannelBuffer s = components[i];
301 int adjustment = indices[i];
302 int localLength = Math.min(length, s.capacity() - (index - adjustment));
303 s.getBytes(index - adjustment, dst, dstIndex, localLength);
304 index += localLength;
305 dstIndex += localLength;
306 length -= localLength;
307 i ++;
308 }
309 }
310
311 public int getBytes(int index, GatheringByteChannel out, int length)
312 throws IOException {
313
314 if (useGathering()) {
315 return (int) out.write(toByteBuffers(index, length));
316 }
317
318 // XXX Gathering write is not supported because of a known issue.
319 // See http://bugs.sun.com/view_bug.do?bug_id=6210541
320 // This issue appeared in 2004 and is still unresolved!?
321 return out.write(toByteBuffer(index, length));
322 }
323
324 public void getBytes(int index, OutputStream out, int length)
325 throws IOException {
326 if (index > capacity() - length) {
327 throw new IndexOutOfBoundsException("Too many bytes to be read - needs "
328 + (index + length) + ", maximum of " + capacity());
329 }
330 if (index < 0) {
331 throw new IndexOutOfBoundsException("Index must be >= 0");
332 }
333 if (length == 0) {
334 return;
335 }
336 int i = componentId(index);
337 while (length > 0) {
338 ChannelBuffer s = components[i];
339 int adjustment = indices[i];
340 int localLength = Math.min(length, s.capacity() - (index - adjustment));
341 s.getBytes(index - adjustment, out, localLength);
342 index += localLength;
343 length -= localLength;
344 i ++;
345 }
346 }
347
348 public void setByte(int index, int value) {
349 int componentId = componentId(index);
350 components[componentId].setByte(index - indices[componentId], value);
351 }
352
353 public void setShort(int index, int value) {
354 int componentId = componentId(index);
355 if (index + 2 <= indices[componentId + 1]) {
356 components[componentId].setShort(index - indices[componentId], value);
357 } else if (order() == ByteOrder.BIG_ENDIAN) {
358 setByte(index, (byte) (value >>> 8));
359 setByte(index + 1, (byte) value);
360 } else {
361 setByte(index , (byte) value);
362 setByte(index + 1, (byte) (value >>> 8));
363 }
364 }
365
366 public void setMedium(int index, int value) {
367 int componentId = componentId(index);
368 if (index + 3 <= indices[componentId + 1]) {
369 components[componentId].setMedium(index - indices[componentId], value);
370 } else if (order() == ByteOrder.BIG_ENDIAN) {
371 setShort(index, (short) (value >> 8));
372 setByte(index + 2, (byte) value);
373 } else {
374 setShort(index , (short) value);
375 setByte(index + 2, (byte) (value >>> 16));
376 }
377 }
378
379 public void setInt(int index, int value) {
380 int componentId = componentId(index);
381 if (index + 4 <= indices[componentId + 1]) {
382 components[componentId].setInt(index - indices[componentId], value);
383 } else if (order() == ByteOrder.BIG_ENDIAN) {
384 setShort(index, (short) (value >>> 16));
385 setShort(index + 2, (short) value);
386 } else {
387 setShort(index , (short) value);
388 setShort(index + 2, (short) (value >>> 16));
389 }
390 }
391
392 public void setLong(int index, long value) {
393 int componentId = componentId(index);
394 if (index + 8 <= indices[componentId + 1]) {
395 components[componentId].setLong(index - indices[componentId], value);
396 } else if (order() == ByteOrder.BIG_ENDIAN) {
397 setInt(index, (int) (value >>> 32));
398 setInt(index + 4, (int) value);
399 } else {
400 setInt(index , (int) value);
401 setInt(index + 4, (int) (value >>> 32));
402 }
403 }
404
405 public void setBytes(int index, byte[] src, int srcIndex, int length) {
406 int componentId = componentId(index);
407 if (index > capacity() - length || srcIndex > src.length - length) {
408 throw new IndexOutOfBoundsException("Too many bytes to read - needs "
409 + (index + length) + " or " + (srcIndex + length) + ", maximum is "
410 + capacity() + " or " + src.length);
411 }
412
413 int i = componentId;
414 while (length > 0) {
415 ChannelBuffer s = components[i];
416 int adjustment = indices[i];
417 int localLength = Math.min(length, s.capacity() - (index - adjustment));
418 s.setBytes(index - adjustment, src, srcIndex, localLength);
419 index += localLength;
420 srcIndex += localLength;
421 length -= localLength;
422 i ++;
423 }
424 }
425
426 public void setBytes(int index, ByteBuffer src) {
427 int componentId = componentId(index);
428 int limit = src.limit();
429 int length = src.remaining();
430 if (index > capacity() - length) {
431 throw new IndexOutOfBoundsException("Too many bytes to be written - Needs "
432 + (index + length) + ", maximum is " + capacity());
433 }
434
435 int i = componentId;
436 try {
437 while (length > 0) {
438 ChannelBuffer s = components[i];
439 int adjustment = indices[i];
440 int localLength = Math.min(length, s.capacity() - (index - adjustment));
441 src.limit(src.position() + localLength);
442 s.setBytes(index - adjustment, src);
443 index += localLength;
444 length -= localLength;
445 i ++;
446 }
447 } finally {
448 src.limit(limit);
449 }
450 }
451
452 public void setBytes(int index, ChannelBuffer src, int srcIndex, int length) {
453 int componentId = componentId(index);
454 if (index > capacity() - length || srcIndex > src.capacity() - length) {
455 throw new IndexOutOfBoundsException("Too many bytes to be written - Needs "
456 + (index + length) + " or " + (srcIndex + length) + ", maximum is "
457 + capacity() + " or " + src.capacity());
458 }
459
460 int i = componentId;
461 while (length > 0) {
462 ChannelBuffer s = components[i];
463 int adjustment = indices[i];
464 int localLength = Math.min(length, s.capacity() - (index - adjustment));
465 s.setBytes(index - adjustment, src, srcIndex, localLength);
466 index += localLength;
467 srcIndex += localLength;
468 length -= localLength;
469 i ++;
470 }
471 }
472
473 public int setBytes(int index, InputStream in, int length)
474 throws IOException {
475 int componentId = componentId(index);
476 if (index > capacity() - length) {
477 throw new IndexOutOfBoundsException("Too many bytes to write - Needs "
478 + (index + length) + ", maximum is " + capacity());
479 }
480
481 int i = componentId;
482 int readBytes = 0;
483
484 do {
485 ChannelBuffer s = components[i];
486 int adjustment = indices[i];
487 int localLength = Math.min(length, s.capacity() - (index - adjustment));
488 int localReadBytes = s.setBytes(index - adjustment, in, localLength);
489 if (localReadBytes < 0) {
490 if (readBytes == 0) {
491 return -1;
492 } else {
493 break;
494 }
495 }
496
497 if (localReadBytes == localLength) {
498 index += localLength;
499 length -= localLength;
500 readBytes += localLength;
501 i ++;
502 } else {
503 index += localReadBytes;
504 length -= localReadBytes;
505 readBytes += localReadBytes;
506 }
507 } while (length > 0);
508
509 return readBytes;
510 }
511
512 public int setBytes(int index, ScatteringByteChannel in, int length)
513 throws IOException {
514 int componentId = componentId(index);
515 if (index > capacity() - length) {
516 throw new IndexOutOfBoundsException("Too many bytes to write - Needs "
517 + (index + length) + ", maximum is " + capacity());
518 }
519
520 int i = componentId;
521 int readBytes = 0;
522 do {
523 ChannelBuffer s = components[i];
524 int adjustment = indices[i];
525 int localLength = Math.min(length, s.capacity() - (index - adjustment));
526 int localReadBytes = s.setBytes(index - adjustment, in, localLength);
527
528 if (localReadBytes == 0) {
529 break;
530 }
531
532 if (localReadBytes < 0) {
533 if (readBytes == 0) {
534 return -1;
535 } else {
536 break;
537 }
538 }
539
540 if (localReadBytes == localLength) {
541 index += localLength;
542 length -= localLength;
543 readBytes += localLength;
544 i ++;
545 } else {
546 index += localReadBytes;
547 length -= localReadBytes;
548 readBytes += localReadBytes;
549 }
550 } while (length > 0);
551
552 return readBytes;
553 }
554
555 public ChannelBuffer duplicate() {
556 ChannelBuffer duplicate = new CompositeChannelBuffer(this);
557 duplicate.setIndex(readerIndex(), writerIndex());
558 return duplicate;
559 }
560
561 public ChannelBuffer copy(int index, int length) {
562 int componentId = componentId(index);
563 if (index > capacity() - length) {
564 throw new IndexOutOfBoundsException("Too many bytes to copy - Needs "
565 + (index + length) + ", maximum is " + capacity());
566 }
567
568 ChannelBuffer dst = factory().getBuffer(order(), length);
569 copyTo(index, length, componentId, dst);
570 return dst;
571 }
572
573 private void copyTo(int index, int length, int componentId, ChannelBuffer dst) {
574 int dstIndex = 0;
575 int i = componentId;
576
577 while (length > 0) {
578 ChannelBuffer s = components[i];
579 int adjustment = indices[i];
580 int localLength = Math.min(length, s.capacity() - (index - adjustment));
581 s.getBytes(index - adjustment, dst, dstIndex, localLength);
582 index += localLength;
583 dstIndex += localLength;
584 length -= localLength;
585 i ++;
586 }
587
588 dst.writerIndex(dst.capacity());
589 }
590
591 /**
592 * Returns the {@link ChannelBuffer} portion of this {@link CompositeChannelBuffer} that
593 * contains the specified {@code index}. <strong>This is an expert method!</strong>
594 *
595 * <p>
596 * Please note that since a {@link CompositeChannelBuffer} is made up of
597 * multiple {@link ChannelBuffer}s, this does <em>not</em> return the full buffer.
598 * Instead, it only returns a portion of the composite buffer where the
599 * index is located
600 * </p>
601 *
602 *
603 * @param index The {@code index} to search for and include in the returned {@link ChannelBuffer}
604 * @return The {@link ChannelBuffer} that contains the specified {@code index}
605 * @throws IndexOutOfBoundsException when the specified {@code index} is
606 * less than zero, or larger than {@code capacity()}
607 */
608 public ChannelBuffer getBuffer(int index) {
609 if (index < 0 || index >= capacity()) {
610 throw new IndexOutOfBoundsException("Invalid index: " + index
611 + " - Bytes needed: " + index + ", maximum is "
612 + capacity());
613 }
614
615 //Return the component byte buffer
616 return components[componentId(index)];
617 }
618
619 public ChannelBuffer slice(int index, int length) {
620 if (index == 0) {
621 if (length == 0) {
622 return ChannelBuffers.EMPTY_BUFFER;
623 }
624 } else if (index < 0 || index > capacity() - length) {
625 throw new IndexOutOfBoundsException("Invalid index: " + index
626 + " - Bytes needed: " + (index + length) + ", maximum is "
627 + capacity());
628 } else if (length == 0) {
629 return ChannelBuffers.EMPTY_BUFFER;
630 }
631
632 List<ChannelBuffer> components = decompose(index, length);
633 switch (components.size()) {
634 case 0:
635 return ChannelBuffers.EMPTY_BUFFER;
636 case 1:
637 return components.get(0);
638 default:
639 return new CompositeChannelBuffer(order(), components, gathering);
640 }
641 }
642
643 public ByteBuffer toByteBuffer(int index, int length) {
644 if (components.length == 1) {
645 return components[0].toByteBuffer(index, length);
646 }
647
648 ByteBuffer[] buffers = toByteBuffers(index, length);
649 ByteBuffer merged = ByteBuffer.allocate(length).order(order());
650 for (ByteBuffer b: buffers) {
651 merged.put(b);
652 }
653 merged.flip();
654 return merged;
655 }
656
657 @Override
658 public ByteBuffer[] toByteBuffers(int index, int length) {
659 if (index + length > capacity()) {
660 throw new IndexOutOfBoundsException("Too many bytes to convert - Needs"
661 + (index + length) + ", maximum is " + capacity());
662 }
663 if (index < 0) {
664 throw new IndexOutOfBoundsException("Index must be >= 0");
665 }
666 if (length == 0) {
667 return new ByteBuffer[0];
668 }
669
670 List<ByteBuffer> buffers = new ArrayList<ByteBuffer>(components.length);
671
672 int i = componentId(index);
673 while (length > 0) {
674 ChannelBuffer s = components[i];
675 int adjustment = indices[i];
676 int localLength = Math.min(length, s.capacity() - (index - adjustment));
677 buffers.add(s.toByteBuffer(index - adjustment, localLength));
678 index += localLength;
679 length -= localLength;
680 i ++;
681 }
682
683 return buffers.toArray(new ByteBuffer[buffers.size()]);
684 }
685
686 private int componentId(int index) {
687 int lastComponentId = lastAccessedComponentId;
688 if (index >= indices[lastComponentId]) {
689 if (index < indices[lastComponentId + 1]) {
690 return lastComponentId;
691 }
692
693 // Search right
694 for (int i = lastComponentId + 1; i < components.length; i ++) {
695 if (index < indices[i + 1]) {
696 lastAccessedComponentId = i;
697 return i;
698 }
699 }
700 } else {
701 // Search left
702 for (int i = lastComponentId - 1; i >= 0; i --) {
703 if (index >= indices[i]) {
704 lastAccessedComponentId = i;
705 return i;
706 }
707 }
708 }
709
710 throw new IndexOutOfBoundsException("Invalid index: " + index + ", maximum: " + indices.length);
711 }
712
713 @Override
714 public void discardReadBytes() {
715 // Only the bytes between readerIndex and writerIndex will be kept.
716 // New readerIndex and writerIndex will become 0 and
717 // (previous writerIndex - previous readerIndex) respectively.
718
719 final int localReaderIndex = readerIndex();
720 if (localReaderIndex == 0) {
721 return;
722 }
723 int localWriterIndex = writerIndex();
724
725 final int bytesToMove = capacity() - localReaderIndex;
726 List<ChannelBuffer> list = decompose(localReaderIndex, bytesToMove);
727
728 // If the list is empty we need to assign a new one because
729 // we get a List that is immutable.
730 //
731 // See https://github.com/netty/netty/issues/325
732 if (list.isEmpty()) {
733 list = new ArrayList<ChannelBuffer>(1);
734 }
735 // Add a new buffer so that the capacity of this composite buffer does
736 // not decrease due to the discarded components.
737 // XXX Might create too many components if discarded by small amount.
738 final ChannelBuffer padding = ChannelBuffers.buffer(order(), localReaderIndex);
739 padding.writerIndex(localReaderIndex);
740 list.add(padding);
741
742 // Reset the index markers to get the index marker values.
743 int localMarkedReaderIndex = localReaderIndex;
744 try {
745 resetReaderIndex();
746 localMarkedReaderIndex = readerIndex();
747 } catch (IndexOutOfBoundsException e) {
748 // ignore
749 }
750 int localMarkedWriterIndex = localWriterIndex;
751 try {
752 resetWriterIndex();
753 localMarkedWriterIndex = writerIndex();
754 } catch (IndexOutOfBoundsException e) {
755 // ignore
756 }
757
758 setComponents(list);
759
760 // reset marked Indexes
761 localMarkedReaderIndex = Math.max(localMarkedReaderIndex - localReaderIndex, 0);
762 localMarkedWriterIndex = Math.max(localMarkedWriterIndex - localReaderIndex, 0);
763 setIndex(localMarkedReaderIndex, localMarkedWriterIndex);
764 markReaderIndex();
765 markWriterIndex();
766 // reset real indexes
767 localWriterIndex = Math.max(localWriterIndex - localReaderIndex, 0);
768 setIndex(0, localWriterIndex);
769 }
770
771 @Override
772 public String toString() {
773 String result = super.toString();
774 result = result.substring(0, result.length() - 1);
775 return result + ", components=" + components.length + ')';
776 }
777 }
以上源码来自： 即时通讯网 - 即时通讯开发者社区！