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 org.jboss.netty.buffer;
    17
    18  import java.io.IOException;
    19  import java.io.InputStream;
    20  import java.io.OutputStream;
    21  import java.nio.ByteBuffer;
    22  import java.nio.ByteOrder;
    23  import java.nio.channels.GatheringByteChannel;
    24  import java.nio.channels.ScatteringByteChannel;
    25
    26
    27  /**
    28   * A derived buffer which simply forwards all data access requests to its
    29   * parent.  It is recommended to use {@link ChannelBuffer#duplicate()} instead
    30   * of calling the constructor explicitly.
    31   */
    32  public class DuplicatedChannelBuffer extends AbstractChannelBuffer implements WrappedChannelBuffer {
    33
    34      private final ChannelBuffer buffer;
    35
    36      public DuplicatedChannelBuffer(ChannelBuffer buffer) {
    37          if (buffer == null) {
    38              throw new NullPointerException("buffer");
    39          }
    40          this.buffer = buffer;
    41          setIndex(buffer.readerIndex(), buffer.writerIndex());
    42      }
    43
    44      private DuplicatedChannelBuffer(DuplicatedChannelBuffer buffer) {
    45          this.buffer = buffer.buffer;
    46          setIndex(buffer.readerIndex(), buffer.writerIndex());
    47      }
    48
    49      public ChannelBuffer unwrap() {
    50          return buffer;
    51      }
    52
    53      public ChannelBufferFactory factory() {
    54          return buffer.factory();
    55      }
    56
    57      public ByteOrder order() {
    58          return buffer.order();
    59      }
    60
    61      public boolean isDirect() {
    62          return buffer.isDirect();
    63      }
    64
    65      public int capacity() {
    66          return buffer.capacity();
    67      }
    68
    69      public boolean hasArray() {
    70          return buffer.hasArray();
    71      }
    72
    73      public byte[] array() {
    74          return buffer.array();
    75      }
    76
    77      public int arrayOffset() {
    78          return buffer.arrayOffset();
    79      }
    80
    81      public byte getByte(int index) {
    82          return buffer.getByte(index);
    83      }
    84
    85      public short getShort(int index) {
    86          return buffer.getShort(index);
    87      }
    88
    89      public int getUnsignedMedium(int index) {
    90          return buffer.getUnsignedMedium(index);
    91      }
    92
    93      public int getInt(int index) {
    94          return buffer.getInt(index);
    95      }
    96
    97      public long getLong(int index) {
    98          return buffer.getLong(index);
    99      }
    100
    101     public ChannelBuffer duplicate() {
    102         return new DuplicatedChannelBuffer(this);
    103     }
    104
    105     public ChannelBuffer copy(int index, int length) {
    106         return buffer.copy(index, length);
    107     }
    108
    109     public ChannelBuffer slice(int index, int length) {
    110         return buffer.slice(index, length);
    111     }
    112
    113     public void getBytes(int index, ChannelBuffer dst, int dstIndex, int length) {
    114         buffer.getBytes(index, dst, dstIndex, length);
    115     }
    116
    117     public void getBytes(int index, byte[] dst, int dstIndex, int length) {
    118         buffer.getBytes(index, dst, dstIndex, length);
    119     }
    120
    121     public void getBytes(int index, ByteBuffer dst) {
    122         buffer.getBytes(index, dst);
    123     }
    124
    125     public void setByte(int index, int value) {
    126         buffer.setByte(index, value);
    127     }
    128
    129     public void setShort(int index, int value) {
    130         buffer.setShort(index, value);
    131     }
    132
    133     public void setMedium(int index, int value) {
    134         buffer.setMedium(index, value);
    135     }
    136
    137     public void setInt(int index, int value) {
    138         buffer.setInt(index, value);
    139     }
    140
    141     public void setLong(int index, long value) {
    142         buffer.setLong(index, value);
    143     }
    144
    145     public void setBytes(int index, byte[] src, int srcIndex, int length) {
    146         buffer.setBytes(index, src, srcIndex, length);
    147     }
    148
    149     public void setBytes(int index, ChannelBuffer src, int srcIndex, int length) {
    150         buffer.setBytes(index, src, srcIndex, length);
    151     }
    152
    153     public void setBytes(int index, ByteBuffer src) {
    154         buffer.setBytes(index, src);
    155     }
    156
    157     public void getBytes(int index, OutputStream out, int length)
    158             throws IOException {
    159         buffer.getBytes(index, out, length);
    160     }
    161
    162     public int getBytes(int index, GatheringByteChannel out, int length)
    163             throws IOException {
    164         return buffer.getBytes(index, out, length);
    165     }
    166
    167     public int setBytes(int index, InputStream in, int length)
    168             throws IOException {
    169         return buffer.setBytes(index, in, length);
    170     }
    171
    172     public int setBytes(int index, ScatteringByteChannel in, int length)
    173             throws IOException {
    174         return buffer.setBytes(index, in, length);
    175     }
    176
    177     public ByteBuffer toByteBuffer(int index, int length) {
    178         return buffer.toByteBuffer(index, length);
    179     }
    180 }