View Javadoc
1   /*
2    * Copyright 2016 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    *   https://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  
17  package io.netty.buffer;
18  
19  import io.netty.util.ByteProcessor;
20  import io.netty.util.internal.ObjectPool;
21  import io.netty.util.internal.ObjectPool.Handle;
22  import io.netty.util.internal.ObjectPool.ObjectCreator;
23  
24  import java.io.IOException;
25  import java.io.InputStream;
26  import java.io.OutputStream;
27  import java.nio.ByteBuffer;
28  import java.nio.channels.FileChannel;
29  import java.nio.channels.GatheringByteChannel;
30  import java.nio.channels.ScatteringByteChannel;
31  
32  import static io.netty.buffer.AbstractUnpooledSlicedByteBuf.checkSliceOutOfBounds;
33  
34  final class PooledSlicedByteBuf extends AbstractPooledDerivedByteBuf {
35  
36      private static final ObjectPool<PooledSlicedByteBuf> RECYCLER = ObjectPool.newPool(
37              new ObjectCreator<PooledSlicedByteBuf>() {
38          @Override
39          public PooledSlicedByteBuf newObject(Handle<PooledSlicedByteBuf> handle) {
40              return new PooledSlicedByteBuf(handle);
41          }
42      });
43  
44      static PooledSlicedByteBuf newInstance(AbstractByteBuf unwrapped, ByteBuf wrapped,
45                                             int index, int length) {
46          checkSliceOutOfBounds(index, length, unwrapped);
47          return newInstance0(unwrapped, wrapped, index, length);
48      }
49  
50      private static PooledSlicedByteBuf newInstance0(AbstractByteBuf unwrapped, ByteBuf wrapped,
51                                                      int adjustment, int length) {
52          final PooledSlicedByteBuf slice = RECYCLER.get();
53          slice.init(unwrapped, wrapped, 0, length, length);
54          slice.discardMarks();
55          slice.adjustment = adjustment;
56  
57          return slice;
58      }
59  
60      int adjustment;
61  
62      private PooledSlicedByteBuf(Handle<PooledSlicedByteBuf> handle) {
63          super(handle);
64      }
65  
66      @Override
67      public int capacity() {
68          return maxCapacity();
69      }
70  
71      @Override
72      public ByteBuf capacity(int newCapacity) {
73          throw new UnsupportedOperationException("sliced buffer");
74      }
75  
76      @Override
77      public int arrayOffset() {
78          return idx(unwrap().arrayOffset());
79      }
80  
81      @Override
82      public long memoryAddress() {
83          return unwrap().memoryAddress() + adjustment;
84      }
85  
86      @Override
87      public ByteBuffer nioBuffer(int index, int length) {
88          checkIndex0(index, length);
89          return unwrap().nioBuffer(idx(index), length);
90      }
91  
92      @Override
93      public ByteBuffer[] nioBuffers(int index, int length) {
94          checkIndex0(index, length);
95          return unwrap().nioBuffers(idx(index), length);
96      }
97  
98      @Override
99      public ByteBuf copy(int index, int length) {
100         checkIndex0(index, length);
101         return unwrap().copy(idx(index), length);
102     }
103 
104     @Override
105     public ByteBuf slice(int index, int length) {
106         checkIndex0(index, length);
107         return super.slice(idx(index), length);
108     }
109 
110     @Override
111     public ByteBuf retainedSlice(int index, int length) {
112         checkIndex0(index, length);
113         return PooledSlicedByteBuf.newInstance0(unwrap(), this, idx(index), length);
114     }
115 
116     @Override
117     public ByteBuf duplicate() {
118         return slice(0, capacity()).setIndex(readerIndex(), writerIndex());
119     }
120 
121     @Override
122     public ByteBuf retainedDuplicate() {
123         return retainedSlice(0, capacity()).setIndex(readerIndex(), writerIndex());
124     }
125 
126     @Override
127     public byte getByte(int index) {
128         checkIndex0(index, 1);
129         return unwrap().getByte(idx(index));
130     }
131 
132     @Override
133     protected byte _getByte(int index) {
134         return unwrap()._getByte(idx(index));
135     }
136 
137     @Override
138     public short getShort(int index) {
139         checkIndex0(index, 2);
140         return unwrap().getShort(idx(index));
141     }
142 
143     @Override
144     protected short _getShort(int index) {
145         return unwrap()._getShort(idx(index));
146     }
147 
148     @Override
149     public short getShortLE(int index) {
150         checkIndex0(index, 2);
151         return unwrap().getShortLE(idx(index));
152     }
153 
154     @Override
155     protected short _getShortLE(int index) {
156         return unwrap()._getShortLE(idx(index));
157     }
158 
159     @Override
160     public int getUnsignedMedium(int index) {
161         checkIndex0(index, 3);
162         return unwrap().getUnsignedMedium(idx(index));
163     }
164 
165     @Override
166     protected int _getUnsignedMedium(int index) {
167         return unwrap()._getUnsignedMedium(idx(index));
168     }
169 
170     @Override
171     public int getUnsignedMediumLE(int index) {
172         checkIndex0(index, 3);
173         return unwrap().getUnsignedMediumLE(idx(index));
174     }
175 
176     @Override
177     protected int _getUnsignedMediumLE(int index) {
178         return unwrap()._getUnsignedMediumLE(idx(index));
179     }
180 
181     @Override
182     public int getInt(int index) {
183         checkIndex0(index, 4);
184         return unwrap().getInt(idx(index));
185     }
186 
187     @Override
188     protected int _getInt(int index) {
189         return unwrap()._getInt(idx(index));
190     }
191 
192     @Override
193     public int getIntLE(int index) {
194         checkIndex0(index, 4);
195         return unwrap().getIntLE(idx(index));
196     }
197 
198     @Override
199     protected int _getIntLE(int index) {
200         return unwrap()._getIntLE(idx(index));
201     }
202 
203     @Override
204     public long getLong(int index) {
205         checkIndex0(index, 8);
206         return unwrap().getLong(idx(index));
207     }
208 
209     @Override
210     protected long _getLong(int index) {
211         return unwrap()._getLong(idx(index));
212     }
213 
214     @Override
215     public long getLongLE(int index) {
216         checkIndex0(index, 8);
217         return unwrap().getLongLE(idx(index));
218     }
219 
220     @Override
221     protected long _getLongLE(int index) {
222         return unwrap()._getLongLE(idx(index));
223     }
224 
225     @Override
226     public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
227         checkIndex0(index, length);
228         unwrap().getBytes(idx(index), dst, dstIndex, length);
229         return this;
230     }
231 
232     @Override
233     public ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
234         checkIndex0(index, length);
235         unwrap().getBytes(idx(index), dst, dstIndex, length);
236         return this;
237     }
238 
239     @Override
240     public ByteBuf getBytes(int index, ByteBuffer dst) {
241         checkIndex0(index, dst.remaining());
242         unwrap().getBytes(idx(index), dst);
243         return this;
244     }
245 
246     @Override
247     public ByteBuf setByte(int index, int value) {
248         checkIndex0(index, 1);
249         unwrap().setByte(idx(index), value);
250         return this;
251     }
252 
253     @Override
254     protected void _setByte(int index, int value) {
255         unwrap()._setByte(idx(index), value);
256     }
257 
258     @Override
259     public ByteBuf setShort(int index, int value) {
260         checkIndex0(index, 2);
261         unwrap().setShort(idx(index), value);
262         return this;
263     }
264 
265     @Override
266     protected void _setShort(int index, int value) {
267         unwrap()._setShort(idx(index), value);
268     }
269 
270     @Override
271     public ByteBuf setShortLE(int index, int value) {
272         checkIndex0(index, 2);
273         unwrap().setShortLE(idx(index), value);
274         return this;
275     }
276 
277     @Override
278     protected void _setShortLE(int index, int value) {
279         unwrap()._setShortLE(idx(index), value);
280     }
281 
282     @Override
283     public ByteBuf setMedium(int index, int value) {
284         checkIndex0(index, 3);
285         unwrap().setMedium(idx(index), value);
286         return this;
287     }
288 
289     @Override
290     protected void _setMedium(int index, int value) {
291         unwrap()._setMedium(idx(index), value);
292     }
293 
294     @Override
295     public ByteBuf setMediumLE(int index, int value) {
296         checkIndex0(index, 3);
297         unwrap().setMediumLE(idx(index), value);
298         return this;
299     }
300 
301     @Override
302     protected void _setMediumLE(int index, int value) {
303         unwrap()._setMediumLE(idx(index), value);
304     }
305 
306     @Override
307     public ByteBuf setInt(int index, int value) {
308         checkIndex0(index, 4);
309         unwrap().setInt(idx(index), value);
310         return this;
311     }
312 
313     @Override
314     protected void _setInt(int index, int value) {
315         unwrap()._setInt(idx(index), value);
316     }
317 
318     @Override
319     public ByteBuf setIntLE(int index, int value) {
320         checkIndex0(index, 4);
321         unwrap().setIntLE(idx(index), value);
322         return this;
323     }
324 
325     @Override
326     protected void _setIntLE(int index, int value) {
327         unwrap()._setIntLE(idx(index), value);
328     }
329 
330     @Override
331     public ByteBuf setLong(int index, long value) {
332         checkIndex0(index, 8);
333         unwrap().setLong(idx(index), value);
334         return this;
335     }
336 
337     @Override
338     protected void _setLong(int index, long value) {
339         unwrap()._setLong(idx(index), value);
340     }
341 
342     @Override
343     public ByteBuf setLongLE(int index, long value) {
344         checkIndex0(index, 8);
345         unwrap().setLongLE(idx(index), value);
346         return this;
347     }
348 
349     @Override
350     protected void _setLongLE(int index, long value) {
351         unwrap().setLongLE(idx(index), value);
352     }
353 
354     @Override
355     public ByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
356         checkIndex0(index, length);
357         unwrap().setBytes(idx(index), src, srcIndex, length);
358         return this;
359     }
360 
361     @Override
362     public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
363         checkIndex0(index, length);
364         unwrap().setBytes(idx(index), src, srcIndex, length);
365         return this;
366     }
367 
368     @Override
369     public ByteBuf setBytes(int index, ByteBuffer src) {
370         checkIndex0(index, src.remaining());
371         unwrap().setBytes(idx(index), src);
372         return this;
373     }
374 
375     @Override
376     public ByteBuf getBytes(int index, OutputStream out, int length)
377             throws IOException {
378         checkIndex0(index, length);
379         unwrap().getBytes(idx(index), out, length);
380         return this;
381     }
382 
383     @Override
384     public int getBytes(int index, GatheringByteChannel out, int length)
385             throws IOException {
386         checkIndex0(index, length);
387         return unwrap().getBytes(idx(index), out, length);
388     }
389 
390     @Override
391     public int getBytes(int index, FileChannel out, long position, int length)
392             throws IOException {
393         checkIndex0(index, length);
394         return unwrap().getBytes(idx(index), out, position, length);
395     }
396 
397     @Override
398     public int setBytes(int index, InputStream in, int length)
399             throws IOException {
400         checkIndex0(index, length);
401         return unwrap().setBytes(idx(index), in, length);
402     }
403 
404     @Override
405     public int setBytes(int index, ScatteringByteChannel in, int length)
406             throws IOException {
407         checkIndex0(index, length);
408         return unwrap().setBytes(idx(index), in, length);
409     }
410 
411     @Override
412     public int setBytes(int index, FileChannel in, long position, int length)
413             throws IOException {
414         checkIndex0(index, length);
415         return unwrap().setBytes(idx(index), in, position, length);
416     }
417 
418     @Override
419     public int forEachByte(int index, int length, ByteProcessor processor) {
420         checkIndex0(index, length);
421         int ret = unwrap().forEachByte(idx(index), length, processor);
422         if (ret < adjustment) {
423             return -1;
424         }
425         return ret - adjustment;
426     }
427 
428     @Override
429     public int forEachByteDesc(int index, int length, ByteProcessor processor) {
430         checkIndex0(index, length);
431         int ret = unwrap().forEachByteDesc(idx(index), length, processor);
432         if (ret < adjustment) {
433             return -1;
434         }
435         return ret - adjustment;
436     }
437 
438     private int idx(int index) {
439         return index + adjustment;
440     }
441 }