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 * 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 package io.netty.buffer;
17
18 import io.netty.util.ByteProcessor;
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.FileChannel;
26 import java.nio.channels.GatheringByteChannel;
27 import java.nio.channels.ScatteringByteChannel;
28
29 /**
30 * A derived buffer which simply forwards all data access requests to its
31 * parent. It is recommended to use {@link ByteBuf#duplicate()} instead
32 * of calling the constructor explicitly.
33 *
34 * @deprecated Do not use.
35 */
36 @Deprecated
37 public class DuplicatedByteBuf extends AbstractDerivedByteBuf {
38
39 private final ByteBuf buffer;
40
41 public DuplicatedByteBuf(ByteBuf buffer) {
42 this(buffer, buffer.readerIndex(), buffer.writerIndex());
43 }
44
45 DuplicatedByteBuf(ByteBuf buffer, int readerIndex, int writerIndex) {
46 super(buffer.maxCapacity());
47
48 if (buffer instanceof DuplicatedByteBuf) {
49 this.buffer = ((DuplicatedByteBuf) buffer).buffer;
50 } else if (buffer instanceof AbstractPooledDerivedByteBuf) {
51 this.buffer = buffer.unwrap();
52 } else {
53 this.buffer = buffer;
54 }
55
56 setIndex(readerIndex, writerIndex);
57 markReaderIndex();
58 markWriterIndex();
59 }
60
61 @Override
62 public ByteBuf unwrap() {
63 return buffer;
64 }
65
66 @Override
67 public ByteBufAllocator alloc() {
68 return unwrap().alloc();
69 }
70
71 @Override
72 @Deprecated
73 public ByteOrder order() {
74 return unwrap().order();
75 }
76
77 @Override
78 public boolean isDirect() {
79 return unwrap().isDirect();
80 }
81
82 @Override
83 public int capacity() {
84 return unwrap().capacity();
85 }
86
87 @Override
88 public ByteBuf capacity(int newCapacity) {
89 unwrap().capacity(newCapacity);
90 return this;
91 }
92
93 @Override
94 public boolean hasArray() {
95 return unwrap().hasArray();
96 }
97
98 @Override
99 public byte[] array() {
100 return unwrap().array();
101 }
102
103 @Override
104 public int arrayOffset() {
105 return unwrap().arrayOffset();
106 }
107
108 @Override
109 public boolean hasMemoryAddress() {
110 return unwrap().hasMemoryAddress();
111 }
112
113 @Override
114 public long memoryAddress() {
115 return unwrap().memoryAddress();
116 }
117
118 @Override
119 public byte getByte(int index) {
120 return unwrap().getByte(index);
121 }
122
123 @Override
124 protected byte _getByte(int index) {
125 return unwrap().getByte(index);
126 }
127
128 @Override
129 public short getShort(int index) {
130 return unwrap().getShort(index);
131 }
132
133 @Override
134 protected short _getShort(int index) {
135 return unwrap().getShort(index);
136 }
137
138 @Override
139 public short getShortLE(int index) {
140 return unwrap().getShortLE(index);
141 }
142
143 @Override
144 protected short _getShortLE(int index) {
145 return unwrap().getShortLE(index);
146 }
147
148 @Override
149 public int getUnsignedMedium(int index) {
150 return unwrap().getUnsignedMedium(index);
151 }
152
153 @Override
154 protected int _getUnsignedMedium(int index) {
155 return unwrap().getUnsignedMedium(index);
156 }
157
158 @Override
159 public int getUnsignedMediumLE(int index) {
160 return unwrap().getUnsignedMediumLE(index);
161 }
162
163 @Override
164 protected int _getUnsignedMediumLE(int index) {
165 return unwrap().getUnsignedMediumLE(index);
166 }
167
168 @Override
169 public int getInt(int index) {
170 return unwrap().getInt(index);
171 }
172
173 @Override
174 protected int _getInt(int index) {
175 return unwrap().getInt(index);
176 }
177
178 @Override
179 public int getIntLE(int index) {
180 return unwrap().getIntLE(index);
181 }
182
183 @Override
184 protected int _getIntLE(int index) {
185 return unwrap().getIntLE(index);
186 }
187
188 @Override
189 public long getLong(int index) {
190 return unwrap().getLong(index);
191 }
192
193 @Override
194 protected long _getLong(int index) {
195 return unwrap().getLong(index);
196 }
197
198 @Override
199 public long getLongLE(int index) {
200 return unwrap().getLongLE(index);
201 }
202
203 @Override
204 protected long _getLongLE(int index) {
205 return unwrap().getLongLE(index);
206 }
207
208 @Override
209 public ByteBuf copy(int index, int length) {
210 return unwrap().copy(index, length);
211 }
212
213 @Override
214 public ByteBuf slice(int index, int length) {
215 return unwrap().slice(index, length);
216 }
217
218 @Override
219 public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
220 unwrap().getBytes(index, dst, dstIndex, length);
221 return this;
222 }
223
224 @Override
225 public ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
226 unwrap().getBytes(index, dst, dstIndex, length);
227 return this;
228 }
229
230 @Override
231 public ByteBuf getBytes(int index, ByteBuffer dst) {
232 unwrap().getBytes(index, dst);
233 return this;
234 }
235
236 @Override
237 public ByteBuf setByte(int index, int value) {
238 unwrap().setByte(index, value);
239 return this;
240 }
241
242 @Override
243 protected void _setByte(int index, int value) {
244 unwrap().setByte(index, value);
245 }
246
247 @Override
248 public ByteBuf setShort(int index, int value) {
249 unwrap().setShort(index, value);
250 return this;
251 }
252
253 @Override
254 protected void _setShort(int index, int value) {
255 unwrap().setShort(index, value);
256 }
257
258 @Override
259 public ByteBuf setShortLE(int index, int value) {
260 unwrap().setShortLE(index, value);
261 return this;
262 }
263
264 @Override
265 protected void _setShortLE(int index, int value) {
266 unwrap().setShortLE(index, value);
267 }
268
269 @Override
270 public ByteBuf setMedium(int index, int value) {
271 unwrap().setMedium(index, value);
272 return this;
273 }
274
275 @Override
276 protected void _setMedium(int index, int value) {
277 unwrap().setMedium(index, value);
278 }
279
280 @Override
281 public ByteBuf setMediumLE(int index, int value) {
282 unwrap().setMediumLE(index, value);
283 return this;
284 }
285
286 @Override
287 protected void _setMediumLE(int index, int value) {
288 unwrap().setMediumLE(index, value);
289 }
290
291 @Override
292 public ByteBuf setInt(int index, int value) {
293 unwrap().setInt(index, value);
294 return this;
295 }
296
297 @Override
298 protected void _setInt(int index, int value) {
299 unwrap().setInt(index, value);
300 }
301
302 @Override
303 public ByteBuf setIntLE(int index, int value) {
304 unwrap().setIntLE(index, value);
305 return this;
306 }
307
308 @Override
309 protected void _setIntLE(int index, int value) {
310 unwrap().setIntLE(index, value);
311 }
312
313 @Override
314 public ByteBuf setLong(int index, long value) {
315 unwrap().setLong(index, value);
316 return this;
317 }
318
319 @Override
320 protected void _setLong(int index, long value) {
321 unwrap().setLong(index, value);
322 }
323
324 @Override
325 public ByteBuf setLongLE(int index, long value) {
326 unwrap().setLongLE(index, value);
327 return this;
328 }
329
330 @Override
331 protected void _setLongLE(int index, long value) {
332 unwrap().setLongLE(index, value);
333 }
334
335 @Override
336 public ByteBuf setBytes(int index, byte[] src, int srcIndex, int length) {
337 unwrap().setBytes(index, src, srcIndex, length);
338 return this;
339 }
340
341 @Override
342 public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
343 unwrap().setBytes(index, src, srcIndex, length);
344 return this;
345 }
346
347 @Override
348 public ByteBuf setBytes(int index, ByteBuffer src) {
349 unwrap().setBytes(index, src);
350 return this;
351 }
352
353 @Override
354 public ByteBuf getBytes(int index, OutputStream out, int length)
355 throws IOException {
356 unwrap().getBytes(index, out, length);
357 return this;
358 }
359
360 @Override
361 public int getBytes(int index, GatheringByteChannel out, int length)
362 throws IOException {
363 return unwrap().getBytes(index, out, length);
364 }
365
366 @Override
367 public int getBytes(int index, FileChannel out, long position, int length)
368 throws IOException {
369 return unwrap().getBytes(index, out, position, length);
370 }
371
372 @Override
373 public int setBytes(int index, InputStream in, int length)
374 throws IOException {
375 return unwrap().setBytes(index, in, length);
376 }
377
378 @Override
379 public int setBytes(int index, ScatteringByteChannel in, int length)
380 throws IOException {
381 return unwrap().setBytes(index, in, length);
382 }
383
384 @Override
385 public int setBytes(int index, FileChannel in, long position, int length)
386 throws IOException {
387 return unwrap().setBytes(index, in, position, length);
388 }
389
390 @Override
391 public int nioBufferCount() {
392 return unwrap().nioBufferCount();
393 }
394
395 @Override
396 public ByteBuffer[] nioBuffers(int index, int length) {
397 return unwrap().nioBuffers(index, length);
398 }
399
400 @Override
401 public int forEachByte(int index, int length, ByteProcessor processor) {
402 return unwrap().forEachByte(index, length, processor);
403 }
404
405 @Override
406 public int forEachByteDesc(int index, int length, ByteProcessor processor) {
407 return unwrap().forEachByteDesc(index, length, processor);
408 }
409 }
410
以上源码来自： 即时通讯网 - 即时通讯开发者社区！