1
2
3
4
5
6
7
8
9
10
11
12
13
14
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.ReadOnlyBufferException;
24 import java.nio.channels.GatheringByteChannel;
25 import java.nio.channels.ScatteringByteChannel;
26
27
28
29
30
31
32
33
34
35
36
37
38 public class ReadOnlyChannelBuffer extends AbstractChannelBuffer implements WrappedChannelBuffer {
39
40 private final ChannelBuffer buffer;
41
42 public ReadOnlyChannelBuffer(ChannelBuffer buffer) {
43 if (buffer == null) {
44 throw new NullPointerException("buffer");
45 }
46 this.buffer = buffer;
47 setIndex(buffer.readerIndex(), buffer.writerIndex());
48 }
49
50 private ReadOnlyChannelBuffer(ReadOnlyChannelBuffer buffer) {
51 this.buffer = buffer.buffer;
52 setIndex(buffer.readerIndex(), buffer.writerIndex());
53 }
54
55 public ChannelBuffer unwrap() {
56 return buffer;
57 }
58
59 public ChannelBufferFactory factory() {
60 return buffer.factory();
61 }
62
63 public ByteOrder order() {
64 return buffer.order();
65 }
66
67 public boolean isDirect() {
68 return buffer.isDirect();
69 }
70
71 public boolean hasArray() {
72 return false;
73 }
74
75 public byte[] array() {
76 throw new ReadOnlyBufferException();
77 }
78
79 public int arrayOffset() {
80 throw new ReadOnlyBufferException();
81 }
82
83 @Override
84 public void discardReadBytes() {
85 throw new ReadOnlyBufferException();
86 }
87
88 public void setByte(int index, int value) {
89 throw new ReadOnlyBufferException();
90 }
91
92 public void setBytes(int index, ChannelBuffer src, int srcIndex, int length) {
93 throw new ReadOnlyBufferException();
94 }
95
96 public void setBytes(int index, byte[] src, int srcIndex, int length) {
97 throw new ReadOnlyBufferException();
98 }
99
100 public void setBytes(int index, ByteBuffer src) {
101 throw new ReadOnlyBufferException();
102 }
103
104 public void setShort(int index, int value) {
105 throw new ReadOnlyBufferException();
106 }
107
108 public void setMedium(int index, int value) {
109 throw new ReadOnlyBufferException();
110 }
111
112 public void setInt(int index, int value) {
113 throw new ReadOnlyBufferException();
114 }
115
116 public void setLong(int index, long value) {
117 throw new ReadOnlyBufferException();
118 }
119
120 public int setBytes(int index, InputStream in, int length)
121 throws IOException {
122 throw new ReadOnlyBufferException();
123 }
124
125 public int setBytes(int index, ScatteringByteChannel in, int length)
126 throws IOException {
127 throw new ReadOnlyBufferException();
128 }
129
130 public int getBytes(int index, GatheringByteChannel out, int length)
131 throws IOException {
132 return buffer.getBytes(index, out, length);
133 }
134
135 public void getBytes(int index, OutputStream out, int length)
136 throws IOException {
137 buffer.getBytes(index, out, length);
138 }
139
140 public void getBytes(int index, byte[] dst, int dstIndex, int length) {
141 buffer.getBytes(index, dst, dstIndex, length);
142 }
143
144 public void getBytes(int index, ChannelBuffer dst, int dstIndex, int length) {
145 buffer.getBytes(index, dst, dstIndex, length);
146 }
147
148 public void getBytes(int index, ByteBuffer dst) {
149 buffer.getBytes(index, dst);
150 }
151
152 public ChannelBuffer duplicate() {
153 return new ReadOnlyChannelBuffer(this);
154 }
155
156 public ChannelBuffer copy(int index, int length) {
157 return buffer.copy(index, length);
158 }
159
160 public ChannelBuffer slice(int index, int length) {
161 return new ReadOnlyChannelBuffer(buffer.slice(index, length));
162 }
163
164 public byte getByte(int index) {
165 return buffer.getByte(index);
166 }
167
168 public short getShort(int index) {
169 return buffer.getShort(index);
170 }
171
172 public int getUnsignedMedium(int index) {
173 return buffer.getUnsignedMedium(index);
174 }
175
176 public int getInt(int index) {
177 return buffer.getInt(index);
178 }
179
180 public long getLong(int index) {
181 return buffer.getLong(index);
182 }
183
184 public ByteBuffer toByteBuffer(int index, int length) {
185 return buffer.toByteBuffer(index, length).asReadOnlyBuffer();
186 }
187
188 @Override
189 public ByteBuffer[] toByteBuffers(int index, int length) {
190 ByteBuffer[] bufs = buffer.toByteBuffers(index, length);
191 for (int i = 0; i < bufs.length; i ++) {
192 bufs[i] = bufs[i].asReadOnlyBuffer();
193 }
194 return bufs;
195 }
196
197 public int capacity() {
198 return buffer.capacity();
199 }
200 }