View Javadoc
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 io.netty.buffer;
17  
18  import io.netty.util.internal.EmptyArrays;
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.Collection;
29  import java.util.Collections;
30  import java.util.ConcurrentModificationException;
31  import java.util.Iterator;
32  import java.util.List;
33  import java.util.ListIterator;
34  import java.util.NoSuchElementException;
35  
36  import static io.netty.util.internal.ObjectUtil.checkNotNull;
37  
38  /**
39   * A virtual buffer which shows multiple buffers as a single merged buffer.  It is recommended to use
40   * {@link ByteBufAllocator#compositeBuffer()} or {@link Unpooled#wrappedBuffer(ByteBuf...)} instead of calling the
41   * constructor explicitly.
42   */
43  public class CompositeByteBuf extends AbstractReferenceCountedByteBuf implements Iterable<ByteBuf> {
44  
45      private static final ByteBuffer EMPTY_NIO_BUFFER = Unpooled.EMPTY_BUFFER.nioBuffer();
46      private static final Iterator<ByteBuf> EMPTY_ITERATOR = Collections.<ByteBuf>emptyList().iterator();
47  
48      private final ByteBufAllocator alloc;
49      private final boolean direct;
50      private final ComponentList components;
51      private final int maxNumComponents;
52  
53      private boolean freed;
54  
55      public CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents) {
56          super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
57          if (alloc == null) {
58              throw new NullPointerException("alloc");
59          }
60          this.alloc = alloc;
61          this.direct = direct;
62          this.maxNumComponents = maxNumComponents;
63          components = newList(maxNumComponents);
64      }
65  
66      public CompositeByteBuf(ByteBufAllocator alloc, boolean direct, int maxNumComponents, ByteBuf... buffers) {
67          this(alloc, direct, maxNumComponents, buffers, 0, buffers.length);
68      }
69  
70      CompositeByteBuf(
71              ByteBufAllocator alloc, boolean direct, int maxNumComponents, ByteBuf[] buffers, int offset, int len) {
72          super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
73          if (alloc == null) {
74              throw new NullPointerException("alloc");
75          }
76          if (maxNumComponents < 2) {
77              throw new IllegalArgumentException(
78                      "maxNumComponents: " + maxNumComponents + " (expected: >= 2)");
79          }
80  
81          this.alloc = alloc;
82          this.direct = direct;
83          this.maxNumComponents = maxNumComponents;
84          components = newList(maxNumComponents);
85  
86          addComponents0(false, 0, buffers, offset, len);
87          consolidateIfNeeded();
88          setIndex(0, capacity());
89      }
90  
91      public CompositeByteBuf(
92              ByteBufAllocator alloc, boolean direct, int maxNumComponents, Iterable<ByteBuf> buffers) {
93          super(AbstractByteBufAllocator.DEFAULT_MAX_CAPACITY);
94          if (alloc == null) {
95              throw new NullPointerException("alloc");
96          }
97          if (maxNumComponents < 2) {
98              throw new IllegalArgumentException(
99                      "maxNumComponents: " + maxNumComponents + " (expected: >= 2)");
100         }
101 
102         this.alloc = alloc;
103         this.direct = direct;
104         this.maxNumComponents = maxNumComponents;
105         components = newList(maxNumComponents);
106 
107         addComponents0(false, 0, buffers);
108         consolidateIfNeeded();
109         setIndex(0, capacity());
110     }
111 
112     private static ComponentList newList(int maxNumComponents) {
113         return new ComponentList(Math.min(AbstractByteBufAllocator.DEFAULT_MAX_COMPONENTS, maxNumComponents));
114     }
115 
116     // Special constructor used by WrappedCompositeByteBuf
117     CompositeByteBuf(ByteBufAllocator alloc) {
118         super(Integer.MAX_VALUE);
119         this.alloc = alloc;
120         direct = false;
121         maxNumComponents = 0;
122         components = null;
123     }
124 
125     /**
126      * Add the given {@link ByteBuf}.
127      * <p>
128      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
129      * If you need to have it increased use {@link #addComponent(boolean, ByteBuf)}.
130      * <p>
131      * {@link ByteBuf#release()} ownership of {@code buffer} is transfered to this {@link CompositeByteBuf}.
132      * @param buffer the {@link ByteBuf} to add. {@link ByteBuf#release()} ownership is transfered to this
133      * {@link CompositeByteBuf}.
134      */
135     public CompositeByteBuf addComponent(ByteBuf buffer) {
136         return addComponent(false, buffer);
137     }
138 
139     /**
140      * Add the given {@link ByteBuf}s.
141      * <p>
142      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
143      * If you need to have it increased use {@link #addComponents(boolean, ByteBuf[])}.
144      * <p>
145      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
146      * {@link CompositeByteBuf}.
147      * @param buffers the {@link ByteBuf}s to add. {@link ByteBuf#release()} ownership of all {@link ByteBuf#release()}
148      * ownership of all {@link ByteBuf} objects is transfered to this {@link CompositeByteBuf}.
149      */
150     public CompositeByteBuf addComponents(ByteBuf... buffers) {
151         return addComponents(false, buffers);
152     }
153 
154     /**
155      * Add the given {@link ByteBuf}s.
156      * <p>
157      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
158      * If you need to have it increased use {@link #addComponents(boolean, Iterable)}.
159      * <p>
160      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
161      * {@link CompositeByteBuf}.
162      * @param buffers the {@link ByteBuf}s to add. {@link ByteBuf#release()} ownership of all {@link ByteBuf#release()}
163      * ownership of all {@link ByteBuf} objects is transfered to this {@link CompositeByteBuf}.
164      */
165     public CompositeByteBuf addComponents(Iterable<ByteBuf> buffers) {
166         return addComponents(false, buffers);
167     }
168 
169     /**
170      * Add the given {@link ByteBuf} on the specific index.
171      * <p>
172      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
173      * If you need to have it increased use {@link #addComponent(boolean, int, ByteBuf)}.
174      * <p>
175      * {@link ByteBuf#release()} ownership of {@code buffer} is transfered to this {@link CompositeByteBuf}.
176      * @param cIndex the index on which the {@link ByteBuf} will be added.
177      * @param buffer the {@link ByteBuf} to add. {@link ByteBuf#release()} ownership is transfered to this
178      * {@link CompositeByteBuf}.
179      */
180     public CompositeByteBuf addComponent(int cIndex, ByteBuf buffer) {
181         return addComponent(false, cIndex, buffer);
182     }
183 
184     /**
185      * Add the given {@link ByteBuf} and increase the {@code writerIndex} if {@code increaseWriterIndex} is
186      * {@code true}.
187      *
188      * {@link ByteBuf#release()} ownership of {@code buffer} is transfered to this {@link CompositeByteBuf}.
189      * @param buffer the {@link ByteBuf} to add. {@link ByteBuf#release()} ownership is transfered to this
190      * {@link CompositeByteBuf}.
191      */
192     public CompositeByteBuf addComponent(boolean increaseWriterIndex, ByteBuf buffer) {
193         checkNotNull(buffer, "buffer");
194         addComponent0(increaseWriterIndex, components.size(), buffer);
195         consolidateIfNeeded();
196         return this;
197     }
198 
199     /**
200      * Add the given {@link ByteBuf}s and increase the {@code writerIndex} if {@code increaseWriterIndex} is
201      * {@code true}.
202      *
203      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
204      * {@link CompositeByteBuf}.
205      * @param buffers the {@link ByteBuf}s to add. {@link ByteBuf#release()} ownership of all {@link ByteBuf#release()}
206      * ownership of all {@link ByteBuf} objects is transfered to this {@link CompositeByteBuf}.
207      */
208     public CompositeByteBuf addComponents(boolean increaseWriterIndex, ByteBuf... buffers) {
209         addComponents0(increaseWriterIndex, components.size(), buffers, 0, buffers.length);
210         consolidateIfNeeded();
211         return this;
212     }
213 
214     /**
215      * Add the given {@link ByteBuf}s and increase the {@code writerIndex} if {@code increaseWriterIndex} is
216      * {@code true}.
217      *
218      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
219      * {@link CompositeByteBuf}.
220      * @param buffers the {@link ByteBuf}s to add. {@link ByteBuf#release()} ownership of all {@link ByteBuf#release()}
221      * ownership of all {@link ByteBuf} objects is transfered to this {@link CompositeByteBuf}.
222      */
223     public CompositeByteBuf addComponents(boolean increaseWriterIndex, Iterable<ByteBuf> buffers) {
224         addComponents0(increaseWriterIndex, components.size(), buffers);
225         consolidateIfNeeded();
226         return this;
227     }
228 
229     /**
230      * Add the given {@link ByteBuf} on the specific index and increase the {@code writerIndex}
231      * if {@code increaseWriterIndex} is {@code true}.
232      *
233      * {@link ByteBuf#release()} ownership of {@code buffer} is transfered to this {@link CompositeByteBuf}.
234      * @param cIndex the index on which the {@link ByteBuf} will be added.
235      * @param buffer the {@link ByteBuf} to add. {@link ByteBuf#release()} ownership is transfered to this
236      * {@link CompositeByteBuf}.
237      */
238     public CompositeByteBuf addComponent(boolean increaseWriterIndex, int cIndex, ByteBuf buffer) {
239         checkNotNull(buffer, "buffer");
240         addComponent0(increaseWriterIndex, cIndex, buffer);
241         consolidateIfNeeded();
242         return this;
243     }
244 
245     /**
246      * Precondition is that {@code buffer != null}.
247      */
248     private int addComponent0(boolean increaseWriterIndex, int cIndex, ByteBuf buffer) {
249         assert buffer != null;
250         boolean wasAdded = false;
251         try {
252             checkComponentIndex(cIndex);
253 
254             int readableBytes = buffer.readableBytes();
255 
256             // No need to consolidate - just add a component to the list.
257             @SuppressWarnings("deprecation")
258             Component c = new Component(buffer.order(ByteOrder.BIG_ENDIAN).slice());
259             if (cIndex == components.size()) {
260                 wasAdded = components.add(c);
261                 if (cIndex == 0) {
262                     c.endOffset = readableBytes;
263                 } else {
264                     Component prev = components.get(cIndex - 1);
265                     c.offset = prev.endOffset;
266                     c.endOffset = c.offset + readableBytes;
267                 }
268             } else {
269                 components.add(cIndex, c);
270                 wasAdded = true;
271                 if (readableBytes != 0) {
272                     updateComponentOffsets(cIndex);
273                 }
274             }
275             if (increaseWriterIndex) {
276                 writerIndex(writerIndex() + buffer.readableBytes());
277             }
278             return cIndex;
279         } finally {
280             if (!wasAdded) {
281                 buffer.release();
282             }
283         }
284     }
285 
286     /**
287      * Add the given {@link ByteBuf}s on the specific index
288      * <p>
289      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
290      * If you need to have it increased you need to handle it by your own.
291      * <p>
292      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
293      * {@link CompositeByteBuf}.
294      * @param cIndex the index on which the {@link ByteBuf} will be added. {@link ByteBuf#release()} ownership of all
295      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects is transfered to this
296      * {@link CompositeByteBuf}.
297      * @param buffers the {@link ByteBuf}s to add. {@link ByteBuf#release()} ownership of all {@link ByteBuf#release()}
298      * ownership of all {@link ByteBuf} objects is transfered to this {@link CompositeByteBuf}.
299      */
300     public CompositeByteBuf addComponents(int cIndex, ByteBuf... buffers) {
301         addComponents0(false, cIndex, buffers, 0, buffers.length);
302         consolidateIfNeeded();
303         return this;
304     }
305 
306     private int addComponents0(boolean increaseWriterIndex, int cIndex, ByteBuf[] buffers, int offset, int len) {
307         checkNotNull(buffers, "buffers");
308         int i = offset;
309         try {
310             checkComponentIndex(cIndex);
311 
312             // No need for consolidation
313             while (i < len) {
314                 // Increment i now to prepare for the next iteration and prevent a duplicate release (addComponent0
315                 // will release if an exception occurs, and we also release in the finally block here).
316                 ByteBuf b = buffers[i++];
317                 if (b == null) {
318                     break;
319                 }
320                 cIndex = addComponent0(increaseWriterIndex, cIndex, b) + 1;
321                 int size = components.size();
322                 if (cIndex > size) {
323                     cIndex = size;
324                 }
325             }
326             return cIndex;
327         } finally {
328             for (; i < len; ++i) {
329                 ByteBuf b = buffers[i];
330                 if (b != null) {
331                     try {
332                         b.release();
333                     } catch (Throwable ignored) {
334                         // ignore
335                     }
336                 }
337             }
338         }
339     }
340 
341     /**
342      * Add the given {@link ByteBuf}s on the specific index
343      *
344      * Be aware that this method does not increase the {@code writerIndex} of the {@link CompositeByteBuf}.
345      * If you need to have it increased you need to handle it by your own.
346      * <p>
347      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects in {@code buffers} is transfered to this
348      * {@link CompositeByteBuf}.
349      * @param cIndex the index on which the {@link ByteBuf} will be added.
350      * @param buffers the {@link ByteBuf}s to add.  {@link ByteBuf#release()} ownership of all
351      * {@link ByteBuf#release()} ownership of all {@link ByteBuf} objects is transfered to this
352      * {@link CompositeByteBuf}.
353      */
354     public CompositeByteBuf addComponents(int cIndex, Iterable<ByteBuf> buffers) {
355         addComponents0(false, cIndex, buffers);
356         consolidateIfNeeded();
357         return this;
358     }
359 
360     private int addComponents0(boolean increaseIndex, int cIndex, Iterable<ByteBuf> buffers) {
361         if (buffers instanceof ByteBuf) {
362             // If buffers also implements ByteBuf (e.g. CompositeByteBuf), it has to go to addComponent(ByteBuf).
363             return addComponent0(increaseIndex, cIndex, (ByteBuf) buffers);
364         }
365         checkNotNull(buffers, "buffers");
366 
367         if (!(buffers instanceof Collection)) {
368             List<ByteBuf> list = new ArrayList<ByteBuf>();
369             try {
370                 for (ByteBuf b: buffers) {
371                     list.add(b);
372                 }
373                 buffers = list;
374             } finally {
375                 if (buffers != list) {
376                     for (ByteBuf b: buffers) {
377                         if (b != null) {
378                             try {
379                                 b.release();
380                             } catch (Throwable ignored) {
381                                 // ignore
382                             }
383                         }
384                     }
385                 }
386             }
387         }
388 
389         Collection<ByteBuf> col = (Collection<ByteBuf>) buffers;
390         return addComponents0(increaseIndex, cIndex, col.toArray(new ByteBuf[col.size()]), 0 , col.size());
391     }
392 
393     /**
394      * This should only be called as last operation from a method as this may adjust the underlying
395      * array of components and so affect the index etc.
396      */
397     private void consolidateIfNeeded() {
398         // Consolidate if the number of components will exceed the allowed maximum by the current
399         // operation.
400         final int numComponents = components.size();
401         if (numComponents > maxNumComponents) {
402             final int capacity = components.get(numComponents - 1).endOffset;
403 
404             ByteBuf consolidated = allocBuffer(capacity);
405 
406             // We're not using foreach to avoid creating an iterator.
407             for (int i = 0; i < numComponents; i ++) {
408                 Component c = components.get(i);
409                 ByteBuf b = c.buf;
410                 consolidated.writeBytes(b);
411                 c.freeIfNecessary();
412             }
413             Component c = new Component(consolidated);
414             c.endOffset = c.length;
415             components.clear();
416             components.add(c);
417         }
418     }
419 
420     private void checkComponentIndex(int cIndex) {
421         ensureAccessible();
422         if (cIndex < 0 || cIndex > components.size()) {
423             throw new IndexOutOfBoundsException(String.format(
424                     "cIndex: %d (expected: >= 0 && <= numComponents(%d))",
425                     cIndex, components.size()));
426         }
427     }
428 
429     private void checkComponentIndex(int cIndex, int numComponents) {
430         ensureAccessible();
431         if (cIndex < 0 || cIndex + numComponents > components.size()) {
432             throw new IndexOutOfBoundsException(String.format(
433                     "cIndex: %d, numComponents: %d " +
434                     "(expected: cIndex >= 0 && cIndex + numComponents <= totalNumComponents(%d))",
435                     cIndex, numComponents, components.size()));
436         }
437     }
438 
439     private void updateComponentOffsets(int cIndex) {
440         int size = components.size();
441         if (size <= cIndex) {
442             return;
443         }
444 
445         Component c = components.get(cIndex);
446         if (cIndex == 0) {
447             c.offset = 0;
448             c.endOffset = c.length;
449             cIndex ++;
450         }
451 
452         for (int i = cIndex; i < size; i ++) {
453             Component prev = components.get(i - 1);
454             Component cur = components.get(i);
455             cur.offset = prev.endOffset;
456             cur.endOffset = cur.offset + cur.length;
457         }
458     }
459 
460     /**
461      * Remove the {@link ByteBuf} from the given index.
462      *
463      * @param cIndex the index on from which the {@link ByteBuf} will be remove
464      */
465     public CompositeByteBuf removeComponent(int cIndex) {
466         checkComponentIndex(cIndex);
467         Component comp = components.remove(cIndex);
468         comp.freeIfNecessary();
469         if (comp.length > 0) {
470             // Only need to call updateComponentOffsets if the length was > 0
471             updateComponentOffsets(cIndex);
472         }
473         return this;
474     }
475 
476     /**
477      * Remove the number of {@link ByteBuf}s starting from the given index.
478      *
479      * @param cIndex the index on which the {@link ByteBuf}s will be started to removed
480      * @param numComponents the number of components to remove
481      */
482     public CompositeByteBuf removeComponents(int cIndex, int numComponents) {
483         checkComponentIndex(cIndex, numComponents);
484 
485         if (numComponents == 0) {
486             return this;
487         }
488         int endIndex = cIndex + numComponents;
489         boolean needsUpdate = false;
490         for (int i = cIndex; i < endIndex; ++i) {
491             Component c = components.get(i);
492             if (c.length > 0) {
493                 needsUpdate = true;
494             }
495             c.freeIfNecessary();
496         }
497         components.removeRange(cIndex, endIndex);
498 
499         if (needsUpdate) {
500             // Only need to call updateComponentOffsets if the length was > 0
501             updateComponentOffsets(cIndex);
502         }
503         return this;
504     }
505 
506     @Override
507     public Iterator<ByteBuf> iterator() {
508         ensureAccessible();
509         if (components.isEmpty()) {
510             return EMPTY_ITERATOR;
511         }
512         return new CompositeByteBufIterator();
513     }
514 
515     /**
516      * Same with {@link #slice(int, int)} except that this method returns a list.
517      */
518     public List<ByteBuf> decompose(int offset, int length) {
519         checkIndex(offset, length);
520         if (length == 0) {
521             return Collections.emptyList();
522         }
523 
524         int componentId = toComponentIndex(offset);
525         List<ByteBuf> slice = new ArrayList<ByteBuf>(components.size());
526 
527         // The first component
528         Component firstC = components.get(componentId);
529         ByteBuf first = firstC.buf.duplicate();
530         first.readerIndex(offset - firstC.offset);
531 
532         ByteBuf buf = first;
533         int bytesToSlice = length;
534         do {
535             int readableBytes = buf.readableBytes();
536             if (bytesToSlice <= readableBytes) {
537                 // Last component
538                 buf.writerIndex(buf.readerIndex() + bytesToSlice);
539                 slice.add(buf);
540                 break;
541             } else {
542                 // Not the last component
543                 slice.add(buf);
544                 bytesToSlice -= readableBytes;
545                 componentId ++;
546 
547                 // Fetch the next component.
548                 buf = components.get(componentId).buf.duplicate();
549             }
550         } while (bytesToSlice > 0);
551 
552         // Slice all components because only readable bytes are interesting.
553         for (int i = 0; i < slice.size(); i ++) {
554             slice.set(i, slice.get(i).slice());
555         }
556 
557         return slice;
558     }
559 
560     @Override
561     public boolean isDirect() {
562         int size = components.size();
563         if (size == 0) {
564             return false;
565         }
566         for (int i = 0; i < size; i++) {
567            if (!components.get(i).buf.isDirect()) {
568                return false;
569            }
570         }
571         return true;
572     }
573 
574     @Override
575     public boolean hasArray() {
576         switch (components.size()) {
577         case 0:
578             return true;
579         case 1:
580             return components.get(0).buf.hasArray();
581         default:
582             return false;
583         }
584     }
585 
586     @Override
587     public byte[] array() {
588         switch (components.size()) {
589         case 0:
590             return EmptyArrays.EMPTY_BYTES;
591         case 1:
592             return components.get(0).buf.array();
593         default:
594             throw new UnsupportedOperationException();
595         }
596     }
597 
598     @Override
599     public int arrayOffset() {
600         switch (components.size()) {
601         case 0:
602             return 0;
603         case 1:
604             return components.get(0).buf.arrayOffset();
605         default:
606             throw new UnsupportedOperationException();
607         }
608     }
609 
610     @Override
611     public boolean hasMemoryAddress() {
612         switch (components.size()) {
613         case 0:
614             return Unpooled.EMPTY_BUFFER.hasMemoryAddress();
615         case 1:
616             return components.get(0).buf.hasMemoryAddress();
617         default:
618             return false;
619         }
620     }
621 
622     @Override
623     public long memoryAddress() {
624         switch (components.size()) {
625         case 0:
626             return Unpooled.EMPTY_BUFFER.memoryAddress();
627         case 1:
628             return components.get(0).buf.memoryAddress();
629         default:
630             throw new UnsupportedOperationException();
631         }
632     }
633 
634     @Override
635     public int capacity() {
636         final int numComponents = components.size();
637         if (numComponents == 0) {
638             return 0;
639         }
640         return components.get(numComponents - 1).endOffset;
641     }
642 
643     @Override
644     public CompositeByteBuf capacity(int newCapacity) {
645         checkNewCapacity(newCapacity);
646 
647         int oldCapacity = capacity();
648         if (newCapacity > oldCapacity) {
649             final int paddingLength = newCapacity - oldCapacity;
650             ByteBuf padding;
651             int nComponents = components.size();
652             if (nComponents < maxNumComponents) {
653                 padding = allocBuffer(paddingLength);
654                 padding.setIndex(0, paddingLength);
655                 addComponent0(false, components.size(), padding);
656             } else {
657                 padding = allocBuffer(paddingLength);
658                 padding.setIndex(0, paddingLength);
659                 // FIXME: No need to create a padding buffer and consolidate.
660                 // Just create a big single buffer and put the current content there.
661                 addComponent0(false, components.size(), padding);
662                 consolidateIfNeeded();
663             }
664         } else if (newCapacity < oldCapacity) {
665             int bytesToTrim = oldCapacity - newCapacity;
666             for (ListIterator<Component> i = components.listIterator(components.size()); i.hasPrevious();) {
667                 Component c = i.previous();
668                 if (bytesToTrim >= c.length) {
669                     bytesToTrim -= c.length;
670                     i.remove();
671                     continue;
672                 }
673 
674                 // Replace the last component with the trimmed slice.
675                 Component newC = new Component(c.buf.slice(0, c.length - bytesToTrim));
676                 newC.offset = c.offset;
677                 newC.endOffset = newC.offset + newC.length;
678                 i.set(newC);
679                 break;
680             }
681 
682             if (readerIndex() > newCapacity) {
683                 setIndex(newCapacity, newCapacity);
684             } else if (writerIndex() > newCapacity) {
685                 writerIndex(newCapacity);
686             }
687         }
688         return this;
689     }
690 
691     @Override
692     public ByteBufAllocator alloc() {
693         return alloc;
694     }
695 
696     @Override
697     public ByteOrder order() {
698         return ByteOrder.BIG_ENDIAN;
699     }
700 
701     /**
702      * Return the current number of {@link ByteBuf}'s that are composed in this instance
703      */
704     public int numComponents() {
705         return components.size();
706     }
707 
708     /**
709      * Return the max number of {@link ByteBuf}'s that are composed in this instance
710      */
711     public int maxNumComponents() {
712         return maxNumComponents;
713     }
714 
715     /**
716      * Return the index for the given offset
717      */
718     public int toComponentIndex(int offset) {
719         checkIndex(offset);
720 
721         for (int low = 0, high = components.size(); low <= high;) {
722             int mid = low + high >>> 1;
723             Component c = components.get(mid);
724             if (offset >= c.endOffset) {
725                 low = mid + 1;
726             } else if (offset < c.offset) {
727                 high = mid - 1;
728             } else {
729                 return mid;
730             }
731         }
732 
733         throw new Error("should not reach here");
734     }
735 
736     public int toByteIndex(int cIndex) {
737         checkComponentIndex(cIndex);
738         return components.get(cIndex).offset;
739     }
740 
741     @Override
742     public byte getByte(int index) {
743         return _getByte(index);
744     }
745 
746     @Override
747     protected byte _getByte(int index) {
748         Component c = findComponent(index);
749         return c.buf.getByte(index - c.offset);
750     }
751 
752     @Override
753     protected short _getShort(int index) {
754         Component c = findComponent(index);
755         if (index + 2 <= c.endOffset) {
756             return c.buf.getShort(index - c.offset);
757         } else if (order() == ByteOrder.BIG_ENDIAN) {
758             return (short) ((_getByte(index) & 0xff) << 8 | _getByte(index + 1) & 0xff);
759         } else {
760             return (short) (_getByte(index) & 0xff | (_getByte(index + 1) & 0xff) << 8);
761         }
762     }
763 
764     @Override
765     protected int _getUnsignedMedium(int index) {
766         Component c = findComponent(index);
767         if (index + 3 <= c.endOffset) {
768             return c.buf.getUnsignedMedium(index - c.offset);
769         } else if (order() == ByteOrder.BIG_ENDIAN) {
770             return (_getShort(index) & 0xffff) << 8 | _getByte(index + 2) & 0xff;
771         } else {
772             return _getShort(index) & 0xFFFF | (_getByte(index + 2) & 0xFF) << 16;
773         }
774     }
775 
776     @Override
777     protected int _getInt(int index) {
778         Component c = findComponent(index);
779         if (index + 4 <= c.endOffset) {
780             return c.buf.getInt(index - c.offset);
781         } else if (order() == ByteOrder.BIG_ENDIAN) {
782             return (_getShort(index) & 0xffff) << 16 | _getShort(index + 2) & 0xffff;
783         } else {
784             return _getShort(index) & 0xFFFF | (_getShort(index + 2) & 0xFFFF) << 16;
785         }
786     }
787 
788     @Override
789     protected long _getLong(int index) {
790         Component c = findComponent(index);
791         if (index + 8 <= c.endOffset) {
792             return c.buf.getLong(index - c.offset);
793         } else if (order() == ByteOrder.BIG_ENDIAN) {
794             return (_getInt(index) & 0xffffffffL) << 32 | _getInt(index + 4) & 0xffffffffL;
795         } else {
796             return _getInt(index) & 0xFFFFFFFFL | (_getInt(index + 4) & 0xFFFFFFFFL) << 32;
797         }
798     }
799 
800     @Override
801     public CompositeByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
802         checkDstIndex(index, length, dstIndex, dst.length);
803         if (length == 0) {
804             return this;
805         }
806 
807         int i = toComponentIndex(index);
808         while (length > 0) {
809             Component c = components.get(i);
810             ByteBuf s = c.buf;
811             int adjustment = c.offset;
812             int localLength = Math.min(length, s.capacity() - (index - adjustment));
813             s.getBytes(index - adjustment, dst, dstIndex, localLength);
814             index += localLength;
815             dstIndex += localLength;
816             length -= localLength;
817             i ++;
818         }
819         return this;
820     }
821 
822     @Override
823     public CompositeByteBuf getBytes(int index, ByteBuffer dst) {
824         int limit = dst.limit();
825         int length = dst.remaining();
826 
827         checkIndex(index, length);
828         if (length == 0) {
829             return this;
830         }
831 
832         int i = toComponentIndex(index);
833         try {
834             while (length > 0) {
835                 Component c = components.get(i);
836                 ByteBuf s = c.buf;
837                 int adjustment = c.offset;
838                 int localLength = Math.min(length, s.capacity() - (index - adjustment));
839                 dst.limit(dst.position() + localLength);
840                 s.getBytes(index - adjustment, dst);
841                 index += localLength;
842                 length -= localLength;
843                 i ++;
844             }
845         } finally {
846             dst.limit(limit);
847         }
848         return this;
849     }
850 
851     @Override
852     public CompositeByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
853         checkDstIndex(index, length, dstIndex, dst.capacity());
854         if (length == 0) {
855             return this;
856         }
857 
858         int i = toComponentIndex(index);
859         while (length > 0) {
860             Component c = components.get(i);
861             ByteBuf s = c.buf;
862             int adjustment = c.offset;
863             int localLength = Math.min(length, s.capacity() - (index - adjustment));
864             s.getBytes(index - adjustment, dst, dstIndex, localLength);
865             index += localLength;
866             dstIndex += localLength;
867             length -= localLength;
868             i ++;
869         }
870         return this;
871     }
872 
873     @Override
874     public int getBytes(int index, GatheringByteChannel out, int length)
875             throws IOException {
876         int count = nioBufferCount();
877         if (count == 1) {
878             return out.write(internalNioBuffer(index, length));
879         } else {
880             long writtenBytes = out.write(nioBuffers(index, length));
881             if (writtenBytes > Integer.MAX_VALUE) {
882                 return Integer.MAX_VALUE;
883             } else {
884                 return (int) writtenBytes;
885             }
886         }
887     }
888 
889     @Override
890     public CompositeByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
891         checkIndex(index, length);
892         if (length == 0) {
893             return this;
894         }
895 
896         int i = toComponentIndex(index);
897         while (length > 0) {
898             Component c = components.get(i);
899             ByteBuf s = c.buf;
900             int adjustment = c.offset;
901             int localLength = Math.min(length, s.capacity() - (index - adjustment));
902             s.getBytes(index - adjustment, out, localLength);
903             index += localLength;
904             length -= localLength;
905             i ++;
906         }
907         return this;
908     }
909 
910     @Override
911     public CompositeByteBuf setByte(int index, int value) {
912         Component c = findComponent(index);
913         c.buf.setByte(index - c.offset, value);
914         return this;
915     }
916 
917     @Override
918     protected void _setByte(int index, int value) {
919         setByte(index, value);
920     }
921 
922     @Override
923     public CompositeByteBuf setShort(int index, int value) {
924         return (CompositeByteBuf) super.setShort(index, value);
925     }
926 
927     @Override
928     protected void _setShort(int index, int value) {
929         Component c = findComponent(index);
930         if (index + 2 <= c.endOffset) {
931             c.buf.setShort(index - c.offset, value);
932         } else if (order() == ByteOrder.BIG_ENDIAN) {
933             _setByte(index, (byte) (value >>> 8));
934             _setByte(index + 1, (byte) value);
935         } else {
936             _setByte(index, (byte) value);
937             _setByte(index + 1, (byte) (value >>> 8));
938         }
939     }
940 
941     @Override
942     public CompositeByteBuf setMedium(int index, int value) {
943         return (CompositeByteBuf) super.setMedium(index, value);
944     }
945 
946     @Override
947     protected void _setMedium(int index, int value) {
948         Component c = findComponent(index);
949         if (index + 3 <= c.endOffset) {
950             c.buf.setMedium(index - c.offset, value);
951         } else if (order() == ByteOrder.BIG_ENDIAN) {
952             _setShort(index, (short) (value >> 8));
953             _setByte(index + 2, (byte) value);
954         } else {
955             _setShort(index, (short) value);
956             _setByte(index + 2, (byte) (value >>> 16));
957         }
958     }
959 
960     @Override
961     public CompositeByteBuf setInt(int index, int value) {
962         return (CompositeByteBuf) super.setInt(index, value);
963     }
964 
965     @Override
966     protected void _setInt(int index, int value) {
967         Component c = findComponent(index);
968         if (index + 4 <= c.endOffset) {
969             c.buf.setInt(index - c.offset, value);
970         } else if (order() == ByteOrder.BIG_ENDIAN) {
971             _setShort(index, (short) (value >>> 16));
972             _setShort(index + 2, (short) value);
973         } else {
974             _setShort(index, (short) value);
975             _setShort(index + 2, (short) (value >>> 16));
976         }
977     }
978 
979     @Override
980     public CompositeByteBuf setLong(int index, long value) {
981         return (CompositeByteBuf) super.setLong(index, value);
982     }
983 
984     @Override
985     protected void _setLong(int index, long value) {
986         Component c = findComponent(index);
987         if (index + 8 <= c.endOffset) {
988             c.buf.setLong(index - c.offset, value);
989         } else if (order() == ByteOrder.BIG_ENDIAN) {
990             _setInt(index, (int) (value >>> 32));
991             _setInt(index + 4, (int) value);
992         } else {
993             _setInt(index, (int) value);
994             _setInt(index + 4, (int) (value >>> 32));
995         }
996     }
997 
998     @Override
999     public CompositeByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
1000         checkSrcIndex(index, length, srcIndex, src.length);
1001         if (length == 0) {
1002             return this;
1003         }
1004 
1005         int i = toComponentIndex(index);
1006         while (length > 0) {
1007             Component c = components.get(i);
1008             ByteBuf s = c.buf;
1009             int adjustment = c.offset;
1010             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1011             s.setBytes(index - adjustment, src, srcIndex, localLength);
1012             index += localLength;
1013             srcIndex += localLength;
1014             length -= localLength;
1015             i ++;
1016         }
1017         return this;
1018     }
1019 
1020     @Override
1021     public CompositeByteBuf setBytes(int index, ByteBuffer src) {
1022         int limit = src.limit();
1023         int length = src.remaining();
1024 
1025         checkIndex(index, length);
1026         if (length == 0) {
1027             return this;
1028         }
1029 
1030         int i = toComponentIndex(index);
1031         try {
1032             while (length > 0) {
1033                 Component c = components.get(i);
1034                 ByteBuf s = c.buf;
1035                 int adjustment = c.offset;
1036                 int localLength = Math.min(length, s.capacity() - (index - adjustment));
1037                 src.limit(src.position() + localLength);
1038                 s.setBytes(index - adjustment, src);
1039                 index += localLength;
1040                 length -= localLength;
1041                 i ++;
1042             }
1043         } finally {
1044             src.limit(limit);
1045         }
1046         return this;
1047     }
1048 
1049     @Override
1050     public CompositeByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
1051         checkSrcIndex(index, length, srcIndex, src.capacity());
1052         if (length == 0) {
1053             return this;
1054         }
1055 
1056         int i = toComponentIndex(index);
1057         while (length > 0) {
1058             Component c = components.get(i);
1059             ByteBuf s = c.buf;
1060             int adjustment = c.offset;
1061             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1062             s.setBytes(index - adjustment, src, srcIndex, localLength);
1063             index += localLength;
1064             srcIndex += localLength;
1065             length -= localLength;
1066             i ++;
1067         }
1068         return this;
1069     }
1070 
1071     @Override
1072     public int setBytes(int index, InputStream in, int length) throws IOException {
1073         checkIndex(index, length);
1074         if (length == 0) {
1075             return in.read(EmptyArrays.EMPTY_BYTES);
1076         }
1077 
1078         int i = toComponentIndex(index);
1079         int readBytes = 0;
1080 
1081         do {
1082             Component c = components.get(i);
1083             ByteBuf s = c.buf;
1084             int adjustment = c.offset;
1085             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1086             int localReadBytes = s.setBytes(index - adjustment, in, localLength);
1087             if (localReadBytes < 0) {
1088                 if (readBytes == 0) {
1089                     return -1;
1090                 } else {
1091                     break;
1092                 }
1093             }
1094 
1095             if (localReadBytes == localLength) {
1096                 index += localLength;
1097                 length -= localLength;
1098                 readBytes += localLength;
1099                 i ++;
1100             } else {
1101                 index += localReadBytes;
1102                 length -= localReadBytes;
1103                 readBytes += localReadBytes;
1104             }
1105         } while (length > 0);
1106 
1107         return readBytes;
1108     }
1109 
1110     @Override
1111     public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException {
1112         checkIndex(index, length);
1113         if (length == 0) {
1114             return in.read(EMPTY_NIO_BUFFER);
1115         }
1116 
1117         int i = toComponentIndex(index);
1118         int readBytes = 0;
1119         do {
1120             Component c = components.get(i);
1121             ByteBuf s = c.buf;
1122             int adjustment = c.offset;
1123             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1124             int localReadBytes = s.setBytes(index - adjustment, in, localLength);
1125 
1126             if (localReadBytes == 0) {
1127                 break;
1128             }
1129 
1130             if (localReadBytes < 0) {
1131                 if (readBytes == 0) {
1132                     return -1;
1133                 } else {
1134                     break;
1135                 }
1136             }
1137 
1138             if (localReadBytes == localLength) {
1139                 index += localLength;
1140                 length -= localLength;
1141                 readBytes += localLength;
1142                 i ++;
1143             } else {
1144                 index += localReadBytes;
1145                 length -= localReadBytes;
1146                 readBytes += localReadBytes;
1147             }
1148         } while (length > 0);
1149 
1150         return readBytes;
1151     }
1152 
1153     @Override
1154     public ByteBuf copy(int index, int length) {
1155         checkIndex(index, length);
1156         ByteBuf dst = allocBuffer(length);
1157         if (length != 0) {
1158             copyTo(index, length, toComponentIndex(index), dst);
1159         }
1160         return dst;
1161     }
1162 
1163     private void copyTo(int index, int length, int componentId, ByteBuf dst) {
1164         int dstIndex = 0;
1165         int i = componentId;
1166 
1167         while (length > 0) {
1168             Component c = components.get(i);
1169             ByteBuf s = c.buf;
1170             int adjustment = c.offset;
1171             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1172             s.getBytes(index - adjustment, dst, dstIndex, localLength);
1173             index += localLength;
1174             dstIndex += localLength;
1175             length -= localLength;
1176             i ++;
1177         }
1178 
1179         dst.writerIndex(dst.capacity());
1180     }
1181 
1182     /**
1183      * Return the {@link ByteBuf} on the specified index
1184      *
1185      * @param cIndex the index for which the {@link ByteBuf} should be returned
1186      * @return buf the {@link ByteBuf} on the specified index
1187      */
1188     public ByteBuf component(int cIndex) {
1189         return internalComponent(cIndex).duplicate();
1190     }
1191 
1192     /**
1193      * Return the {@link ByteBuf} on the specified index
1194      *
1195      * @param offset the offset for which the {@link ByteBuf} should be returned
1196      * @return the {@link ByteBuf} on the specified index
1197      */
1198     public ByteBuf componentAtOffset(int offset) {
1199         return internalComponentAtOffset(offset).duplicate();
1200     }
1201 
1202     /**
1203      * Return the internal {@link ByteBuf} on the specified index. Note that updating the indexes of the returned
1204      * buffer will lead to an undefined behavior of this buffer.
1205      *
1206      * @param cIndex the index for which the {@link ByteBuf} should be returned
1207      */
1208     public ByteBuf internalComponent(int cIndex) {
1209         checkComponentIndex(cIndex);
1210         return components.get(cIndex).buf;
1211     }
1212 
1213     /**
1214      * Return the internal {@link ByteBuf} on the specified offset. Note that updating the indexes of the returned
1215      * buffer will lead to an undefined behavior of this buffer.
1216      *
1217      * @param offset the offset for which the {@link ByteBuf} should be returned
1218      */
1219     public ByteBuf internalComponentAtOffset(int offset) {
1220         return findComponent(offset).buf;
1221     }
1222 
1223     private Component findComponent(int offset) {
1224         checkIndex(offset);
1225 
1226         for (int low = 0, high = components.size(); low <= high;) {
1227             int mid = low + high >>> 1;
1228             Component c = components.get(mid);
1229             if (offset >= c.endOffset) {
1230                 low = mid + 1;
1231             } else if (offset < c.offset) {
1232                 high = mid - 1;
1233             } else {
1234                 assert c.length != 0;
1235                 return c;
1236             }
1237         }
1238 
1239         throw new Error("should not reach here");
1240     }
1241 
1242     @Override
1243     public int nioBufferCount() {
1244         switch (components.size()) {
1245         case 0:
1246             return 1;
1247         case 1:
1248             return components.get(0).buf.nioBufferCount();
1249         default:
1250             int count = 0;
1251             int componentsCount = components.size();
1252             for (int i = 0; i < componentsCount; i++) {
1253                 Component c = components.get(i);
1254                 count += c.buf.nioBufferCount();
1255             }
1256             return count;
1257         }
1258     }
1259 
1260     @Override
1261     public ByteBuffer internalNioBuffer(int index, int length) {
1262         switch (components.size()) {
1263         case 0:
1264             return EMPTY_NIO_BUFFER;
1265         case 1:
1266             return components.get(0).buf.internalNioBuffer(index, length);
1267         default:
1268             throw new UnsupportedOperationException();
1269         }
1270     }
1271 
1272     @Override
1273     public ByteBuffer nioBuffer(int index, int length) {
1274         checkIndex(index, length);
1275 
1276         switch (components.size()) {
1277         case 0:
1278             return EMPTY_NIO_BUFFER;
1279         case 1:
1280             ByteBuf buf = components.get(0).buf;
1281             if (buf.nioBufferCount() == 1) {
1282                 return components.get(0).buf.nioBuffer(index, length);
1283             }
1284         }
1285 
1286         ByteBuffer merged = ByteBuffer.allocate(length).order(order());
1287         ByteBuffer[] buffers = nioBuffers(index, length);
1288 
1289         for (ByteBuffer buf: buffers) {
1290             merged.put(buf);
1291         }
1292 
1293         merged.flip();
1294         return merged;
1295     }
1296 
1297     @Override
1298     public ByteBuffer[] nioBuffers(int index, int length) {
1299         checkIndex(index, length);
1300         if (length == 0) {
1301             return new ByteBuffer[] { EMPTY_NIO_BUFFER };
1302         }
1303 
1304         List<ByteBuffer> buffers = new ArrayList<ByteBuffer>(components.size());
1305         int i = toComponentIndex(index);
1306         while (length > 0) {
1307             Component c = components.get(i);
1308             ByteBuf s = c.buf;
1309             int adjustment = c.offset;
1310             int localLength = Math.min(length, s.capacity() - (index - adjustment));
1311             switch (s.nioBufferCount()) {
1312                 case 0:
1313                     throw new UnsupportedOperationException();
1314                 case 1:
1315                     buffers.add(s.nioBuffer(index - adjustment, localLength));
1316                     break;
1317                 default:
1318                     Collections.addAll(buffers, s.nioBuffers(index - adjustment, localLength));
1319             }
1320 
1321             index += localLength;
1322             length -= localLength;
1323             i ++;
1324         }
1325 
1326         return buffers.toArray(new ByteBuffer[buffers.size()]);
1327     }
1328 
1329     /**
1330      * Consolidate the composed {@link ByteBuf}s
1331      */
1332     public CompositeByteBuf consolidate() {
1333         ensureAccessible();
1334         final int numComponents = numComponents();
1335         if (numComponents <= 1) {
1336             return this;
1337         }
1338 
1339         final Component last = components.get(numComponents - 1);
1340         final int capacity = last.endOffset;
1341         final ByteBuf consolidated = allocBuffer(capacity);
1342 
1343         for (int i = 0; i < numComponents; i ++) {
1344             Component c = components.get(i);
1345             ByteBuf b = c.buf;
1346             consolidated.writeBytes(b);
1347             c.freeIfNecessary();
1348         }
1349 
1350         components.clear();
1351         components.add(new Component(consolidated));
1352         updateComponentOffsets(0);
1353         return this;
1354     }
1355 
1356     /**
1357      * Consolidate the composed {@link ByteBuf}s
1358      *
1359      * @param cIndex the index on which to start to compose
1360      * @param numComponents the number of components to compose
1361      */
1362     public CompositeByteBuf consolidate(int cIndex, int numComponents) {
1363         checkComponentIndex(cIndex, numComponents);
1364         if (numComponents <= 1) {
1365             return this;
1366         }
1367 
1368         final int endCIndex = cIndex + numComponents;
1369         final Component last = components.get(endCIndex - 1);
1370         final int capacity = last.endOffset - components.get(cIndex).offset;
1371         final ByteBuf consolidated = allocBuffer(capacity);
1372 
1373         for (int i = cIndex; i < endCIndex; i ++) {
1374             Component c = components.get(i);
1375             ByteBuf b = c.buf;
1376             consolidated.writeBytes(b);
1377             c.freeIfNecessary();
1378         }
1379 
1380         components.removeRange(cIndex + 1, endCIndex);
1381         components.set(cIndex, new Component(consolidated));
1382         updateComponentOffsets(cIndex);
1383         return this;
1384     }
1385 
1386     /**
1387      * Discard all {@link ByteBuf}s which are read.
1388      */
1389     public CompositeByteBuf discardReadComponents() {
1390         ensureAccessible();
1391         final int readerIndex = readerIndex();
1392         if (readerIndex == 0) {
1393             return this;
1394         }
1395 
1396         // Discard everything if (readerIndex = writerIndex = capacity).
1397         int writerIndex = writerIndex();
1398         if (readerIndex == writerIndex && writerIndex == capacity()) {
1399             int size = components.size();
1400             for (int i = 0; i < size; i++) {
1401                 components.get(i).freeIfNecessary();
1402             }
1403             components.clear();
1404             setIndex(0, 0);
1405             adjustMarkers(readerIndex);
1406             return this;
1407         }
1408 
1409         // Remove read components.
1410         int firstComponentId = toComponentIndex(readerIndex);
1411         for (int i = 0; i < firstComponentId; i ++) {
1412             components.get(i).freeIfNecessary();
1413         }
1414         components.removeRange(0, firstComponentId);
1415 
1416         // Update indexes and markers.
1417         Component first = components.get(0);
1418         int offset = first.offset;
1419         updateComponentOffsets(0);
1420         setIndex(readerIndex - offset, writerIndex - offset);
1421         adjustMarkers(offset);
1422         return this;
1423     }
1424 
1425     @Override
1426     public CompositeByteBuf discardReadBytes() {
1427         ensureAccessible();
1428         final int readerIndex = readerIndex();
1429         if (readerIndex == 0) {
1430             return this;
1431         }
1432 
1433         // Discard everything if (readerIndex = writerIndex = capacity).
1434         int writerIndex = writerIndex();
1435         if (readerIndex == writerIndex && writerIndex == capacity()) {
1436             int size = components.size();
1437             for (int i = 0; i < size; i++) {
1438                 components.get(i).freeIfNecessary();
1439             }
1440             components.clear();
1441             setIndex(0, 0);
1442             adjustMarkers(readerIndex);
1443             return this;
1444         }
1445 
1446         // Remove read components.
1447         int firstComponentId = toComponentIndex(readerIndex);
1448         for (int i = 0; i < firstComponentId; i ++) {
1449             components.get(i).freeIfNecessary();
1450         }
1451 
1452         // Remove or replace the first readable component with a new slice.
1453         Component c = components.get(firstComponentId);
1454         int adjustment = readerIndex - c.offset;
1455         if (adjustment == c.length) {
1456             // new slice would be empty, so remove instead
1457             firstComponentId++;
1458         } else {
1459             Component newC = new Component(c.buf.slice(adjustment, c.length - adjustment));
1460             components.set(firstComponentId, newC);
1461         }
1462 
1463         components.removeRange(0, firstComponentId);
1464 
1465         // Update indexes and markers.
1466         updateComponentOffsets(0);
1467         setIndex(0, writerIndex - readerIndex);
1468         adjustMarkers(readerIndex);
1469         return this;
1470     }
1471 
1472     private ByteBuf allocBuffer(int capacity) {
1473         return direct ? alloc().directBuffer(capacity) : alloc().heapBuffer(capacity);
1474     }
1475 
1476     @Override
1477     public String toString() {
1478         String result = super.toString();
1479         result = result.substring(0, result.length() - 1);
1480         return result + ", components=" + components.size() + ')';
1481     }
1482 
1483     private static final class Component {
1484         final ByteBuf buf;
1485         final int length;
1486         int offset;
1487         int endOffset;
1488 
1489         Component(ByteBuf buf) {
1490             this.buf = buf;
1491             length = buf.readableBytes();
1492         }
1493 
1494         void freeIfNecessary() {
1495             buf.release(); // We should not get a NPE here. If so, it must be a bug.
1496         }
1497     }
1498 
1499     @Override
1500     public CompositeByteBuf readerIndex(int readerIndex) {
1501         return (CompositeByteBuf) super.readerIndex(readerIndex);
1502     }
1503 
1504     @Override
1505     public CompositeByteBuf writerIndex(int writerIndex) {
1506         return (CompositeByteBuf) super.writerIndex(writerIndex);
1507     }
1508 
1509     @Override
1510     public CompositeByteBuf setIndex(int readerIndex, int writerIndex) {
1511         return (CompositeByteBuf) super.setIndex(readerIndex, writerIndex);
1512     }
1513 
1514     @Override
1515     public CompositeByteBuf clear() {
1516         return (CompositeByteBuf) super.clear();
1517     }
1518 
1519     @Override
1520     public CompositeByteBuf markReaderIndex() {
1521         return (CompositeByteBuf) super.markReaderIndex();
1522     }
1523 
1524     @Override
1525     public CompositeByteBuf resetReaderIndex() {
1526         return (CompositeByteBuf) super.resetReaderIndex();
1527     }
1528 
1529     @Override
1530     public CompositeByteBuf markWriterIndex() {
1531         return (CompositeByteBuf) super.markWriterIndex();
1532     }
1533 
1534     @Override
1535     public CompositeByteBuf resetWriterIndex() {
1536         return (CompositeByteBuf) super.resetWriterIndex();
1537     }
1538 
1539     @Override
1540     public CompositeByteBuf ensureWritable(int minWritableBytes) {
1541         return (CompositeByteBuf) super.ensureWritable(minWritableBytes);
1542     }
1543 
1544     @Override
1545     public CompositeByteBuf getBytes(int index, ByteBuf dst) {
1546         return (CompositeByteBuf) super.getBytes(index, dst);
1547     }
1548 
1549     @Override
1550     public CompositeByteBuf getBytes(int index, ByteBuf dst, int length) {
1551         return (CompositeByteBuf) super.getBytes(index, dst, length);
1552     }
1553 
1554     @Override
1555     public CompositeByteBuf getBytes(int index, byte[] dst) {
1556         return (CompositeByteBuf) super.getBytes(index, dst);
1557     }
1558 
1559     @Override
1560     public CompositeByteBuf setBoolean(int index, boolean value) {
1561         return (CompositeByteBuf) super.setBoolean(index, value);
1562     }
1563 
1564     @Override
1565     public CompositeByteBuf setChar(int index, int value) {
1566         return (CompositeByteBuf) super.setChar(index, value);
1567     }
1568 
1569     @Override
1570     public CompositeByteBuf setFloat(int index, float value) {
1571         return (CompositeByteBuf) super.setFloat(index, value);
1572     }
1573 
1574     @Override
1575     public CompositeByteBuf setDouble(int index, double value) {
1576         return (CompositeByteBuf) super.setDouble(index, value);
1577     }
1578 
1579     @Override
1580     public CompositeByteBuf setBytes(int index, ByteBuf src) {
1581         return (CompositeByteBuf) super.setBytes(index, src);
1582     }
1583 
1584     @Override
1585     public CompositeByteBuf setBytes(int index, ByteBuf src, int length) {
1586         return (CompositeByteBuf) super.setBytes(index, src, length);
1587     }
1588 
1589     @Override
1590     public CompositeByteBuf setBytes(int index, byte[] src) {
1591         return (CompositeByteBuf) super.setBytes(index, src);
1592     }
1593 
1594     @Override
1595     public CompositeByteBuf setZero(int index, int length) {
1596         return (CompositeByteBuf) super.setZero(index, length);
1597     }
1598 
1599     @Override
1600     public CompositeByteBuf readBytes(ByteBuf dst) {
1601         return (CompositeByteBuf) super.readBytes(dst);
1602     }
1603 
1604     @Override
1605     public CompositeByteBuf readBytes(ByteBuf dst, int length) {
1606         return (CompositeByteBuf) super.readBytes(dst, length);
1607     }
1608 
1609     @Override
1610     public CompositeByteBuf readBytes(ByteBuf dst, int dstIndex, int length) {
1611         return (CompositeByteBuf) super.readBytes(dst, dstIndex, length);
1612     }
1613 
1614     @Override
1615     public CompositeByteBuf readBytes(byte[] dst) {
1616         return (CompositeByteBuf) super.readBytes(dst);
1617     }
1618 
1619     @Override
1620     public CompositeByteBuf readBytes(byte[] dst, int dstIndex, int length) {
1621         return (CompositeByteBuf) super.readBytes(dst, dstIndex, length);
1622     }
1623 
1624     @Override
1625     public CompositeByteBuf readBytes(ByteBuffer dst) {
1626         return (CompositeByteBuf) super.readBytes(dst);
1627     }
1628 
1629     @Override
1630     public CompositeByteBuf readBytes(OutputStream out, int length) throws IOException {
1631         return (CompositeByteBuf) super.readBytes(out, length);
1632     }
1633 
1634     @Override
1635     public CompositeByteBuf skipBytes(int length) {
1636         return (CompositeByteBuf) super.skipBytes(length);
1637     }
1638 
1639     @Override
1640     public CompositeByteBuf writeBoolean(boolean value) {
1641         return (CompositeByteBuf) super.writeBoolean(value);
1642     }
1643 
1644     @Override
1645     public CompositeByteBuf writeByte(int value) {
1646         return (CompositeByteBuf) super.writeByte(value);
1647     }
1648 
1649     @Override
1650     public CompositeByteBuf writeShort(int value) {
1651         return (CompositeByteBuf) super.writeShort(value);
1652     }
1653 
1654     @Override
1655     public CompositeByteBuf writeMedium(int value) {
1656         return (CompositeByteBuf) super.writeMedium(value);
1657     }
1658 
1659     @Override
1660     public CompositeByteBuf writeInt(int value) {
1661         return (CompositeByteBuf) super.writeInt(value);
1662     }
1663 
1664     @Override
1665     public CompositeByteBuf writeLong(long value) {
1666         return (CompositeByteBuf) super.writeLong(value);
1667     }
1668 
1669     @Override
1670     public CompositeByteBuf writeChar(int value) {
1671         return (CompositeByteBuf) super.writeChar(value);
1672     }
1673 
1674     @Override
1675     public CompositeByteBuf writeFloat(float value) {
1676         return (CompositeByteBuf) super.writeFloat(value);
1677     }
1678 
1679     @Override
1680     public CompositeByteBuf writeDouble(double value) {
1681         return (CompositeByteBuf) super.writeDouble(value);
1682     }
1683 
1684     @Override
1685     public CompositeByteBuf writeBytes(ByteBuf src) {
1686         return (CompositeByteBuf) super.writeBytes(src);
1687     }
1688 
1689     @Override
1690     public CompositeByteBuf writeBytes(ByteBuf src, int length) {
1691         return (CompositeByteBuf) super.writeBytes(src, length);
1692     }
1693 
1694     @Override
1695     public CompositeByteBuf writeBytes(ByteBuf src, int srcIndex, int length) {
1696         return (CompositeByteBuf) super.writeBytes(src, srcIndex, length);
1697     }
1698 
1699     @Override
1700     public CompositeByteBuf writeBytes(byte[] src) {
1701         return (CompositeByteBuf) super.writeBytes(src);
1702     }
1703 
1704     @Override
1705     public CompositeByteBuf writeBytes(byte[] src, int srcIndex, int length) {
1706         return (CompositeByteBuf) super.writeBytes(src, srcIndex, length);
1707     }
1708 
1709     @Override
1710     public CompositeByteBuf writeBytes(ByteBuffer src) {
1711         return (CompositeByteBuf) super.writeBytes(src);
1712     }
1713 
1714     @Override
1715     public CompositeByteBuf writeZero(int length) {
1716         return (CompositeByteBuf) super.writeZero(length);
1717     }
1718 
1719     @Override
1720     public CompositeByteBuf retain(int increment) {
1721         return (CompositeByteBuf) super.retain(increment);
1722     }
1723 
1724     @Override
1725     public CompositeByteBuf retain() {
1726         return (CompositeByteBuf) super.retain();
1727     }
1728 
1729     @Override
1730     public ByteBuffer[] nioBuffers() {
1731         return nioBuffers(readerIndex(), readableBytes());
1732     }
1733 
1734     @Override
1735     public CompositeByteBuf discardSomeReadBytes() {
1736         return discardReadComponents();
1737     }
1738 
1739     @Override
1740     protected void deallocate() {
1741         if (freed) {
1742             return;
1743         }
1744 
1745         freed = true;
1746         int size = components.size();
1747         // We're not using foreach to avoid creating an iterator.
1748         // see https://github.com/netty/netty/issues/2642
1749         for (int i = 0; i < size; i++) {
1750             components.get(i).freeIfNecessary();
1751         }
1752     }
1753 
1754     @Override
1755     public ByteBuf unwrap() {
1756         return null;
1757     }
1758 
1759     private final class CompositeByteBufIterator implements Iterator<ByteBuf> {
1760         private final int size = components.size();
1761         private int index;
1762 
1763         @Override
1764         public boolean hasNext() {
1765             return size > index;
1766         }
1767 
1768         @Override
1769         public ByteBuf next() {
1770             if (size != components.size()) {
1771                 throw new ConcurrentModificationException();
1772             }
1773             if (!hasNext()) {
1774                 throw new NoSuchElementException();
1775             }
1776             try {
1777                 return components.get(index++).buf;
1778             } catch (IndexOutOfBoundsException e) {
1779                 throw new ConcurrentModificationException();
1780             }
1781         }
1782 
1783         @Override
1784         public void remove() {
1785             throw new UnsupportedOperationException("Read-Only");
1786         }
1787     }
1788 
1789     private static final class ComponentList extends ArrayList<Component> {
1790 
1791         ComponentList(int initialCapacity) {
1792             super(initialCapacity);
1793         }
1794 
1795         // Expose this methods so we not need to create a new subList just to remove a range of elements.
1796         @Override
1797         public void removeRange(int fromIndex, int toIndex) {
1798             super.removeRange(fromIndex, toIndex);
1799         }
1800     }
1801 }