1 /* DirectByteBufferImpl.java --
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3
4 This file is part of GNU Classpath.
5
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library. Thus, the terms and
23 conditions of the GNU General Public License cover the whole
24 combination.
25
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module. An independent module is a module which is not derived from
33 or based on this library. If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so. If you do not wish to do so, delete this
36 exception statement from your version. */
37
38
39 package java.nio;
40
41 import gnu.classpath.Pointer;
42
43 abstract class DirectByteBufferImpl extends ByteBuffer
44 {
45 /**
46 * The owner is used to keep alive the object that actually owns the
47 * memory. There are three possibilities:
48 * 1) owner == this: We allocated the memory and we should free it,
49 * but *only* in finalize (if we've been sliced
50 * other objects will also have access to the
51 * memory).
52 * 2) owner == null: The byte buffer was created thru
53 * JNI.NewDirectByteBuffer. The JNI code is
54 * responsible for freeing the memory.
55 * 3) owner == some other object: The other object allocated the
56 * memory and should free it.
57 */
58 private final Object owner;
59
60 static final class ReadOnly extends DirectByteBufferImpl
61 {
62 ReadOnly(Object owner, Pointer address,
63 int capacity, int limit,
64 int position)
65 {
66 super(owner, address, capacity, limit, position);
67 }
68
69 public ByteBuffer put(byte value)
70 {
71 throw new ReadOnlyBufferException ();
72 }
73
74 public ByteBuffer put(int index, byte value)
75 {
76 throw new ReadOnlyBufferException ();
77 }
78
79 public boolean isReadOnly()
80 {
81 return true;
82 }
83 }
84
85 static final class ReadWrite extends DirectByteBufferImpl
86 {
87 ReadWrite(int capacity)
88 {
89 super(capacity);
90 }
91
92 ReadWrite(Object owner, Pointer address,
93 int capacity, int limit,
94 int position)
95 {
96 super(owner, address, capacity, limit, position);
97 }
98
99 public boolean isReadOnly()
100 {
101 return false;
102 }
103 }
104
105 DirectByteBufferImpl(int capacity)
106 {
107 super(capacity, capacity, 0, -1);
108 this.owner = this;
109 this.address = VMDirectByteBuffer.allocate(capacity);
110 }
111
112 DirectByteBufferImpl(Object owner, Pointer address,
113 int capacity, int limit,
114 int position)
115 {
116 super(capacity, limit, position, -1);
117 this.owner = owner;
118 this.address = address;
119 }
120
121 /**
122 * Allocates a new direct byte buffer.
123 */
124 public static ByteBuffer allocate(int capacity)
125 {
126 return new DirectByteBufferImpl.ReadWrite(capacity);
127 }
128
129 protected void finalize() throws Throwable
130 {
131 if (owner == this)
132 VMDirectByteBuffer.free(address);
133 }
134
135 public byte get()
136 {
137 checkForUnderflow();
138
139 int pos = position();
140 byte result = VMDirectByteBuffer.get(address, pos);
141 position(pos + 1);
142 return result;
143 }
144
145 public byte get(int index)
146 {
147 checkIndex(index);
148
149 return VMDirectByteBuffer.get(address, index);
150 }
151
152 public ByteBuffer get(byte[] dst, int offset, int length)
153 {
154 checkArraySize(dst.length, offset, length);
155 checkForUnderflow(length);
156
157 int index = position();
158 VMDirectByteBuffer.get(address, index, dst, offset, length);
159 position(index+length);
160
161 return this;
162 }
163
164 public ByteBuffer put(byte value)
165 {
166 checkForOverflow();
167
168 int pos = position();
169 VMDirectByteBuffer.put(address, pos, value);
170 position(pos + 1);
171 return this;
172 }
173
174 public ByteBuffer put(int index, byte value)
175 {
176 checkIndex(index);
177
178 VMDirectByteBuffer.put(address, index, value);
179 return this;
180 }
181
182 public ByteBuffer put (byte[] src, int offset, int length)
183 {
184 checkArraySize (src.length, offset, length);
185 checkForUnderflow (length);
186
187 int index = position ();
188 VMDirectByteBuffer.put (address, index, src, offset, length);
189 position (index + length);
190
191 return this;
192 }
193
194 void shiftDown(int dst_offset, int src_offset, int count)
195 {
196 VMDirectByteBuffer.shiftDown(address, dst_offset, src_offset, count);
197 }
198
199 public ByteBuffer compact()
200 {
201 checkIfReadOnly();
202 mark = -1;
203 int pos = position();
204 if (pos > 0)
205 {
206 int count = remaining();
207 VMDirectByteBuffer.shiftDown(address, 0, pos, count);
208 position(count);
209 limit(capacity());
210 }
211 else
212 {
213 position(limit());
214 limit(capacity());
215 }
216 return this;
217 }
218
219 public ByteBuffer slice()
220 {
221 int rem = remaining();
222 if (isReadOnly())
223 return new DirectByteBufferImpl.ReadOnly
224 (owner, VMDirectByteBuffer.adjustAddress(address, position()),
225 rem, rem, 0);
226 else
227 return new DirectByteBufferImpl.ReadWrite
228 (owner, VMDirectByteBuffer.adjustAddress(address, position()),
229 rem, rem, 0);
230 }
231
232 private ByteBuffer duplicate(boolean readOnly)
233 {
234 int pos = position();
235 reset();
236 int mark = position();
237 position(pos);
238 DirectByteBufferImpl result;
239 if (readOnly)
240 result = new DirectByteBufferImpl.ReadOnly(owner, address, capacity(),
241 limit(), pos);
242 else
243 result = new DirectByteBufferImpl.ReadWrite(owner, address, capacity(),
244 limit(), pos);
245
246 if (mark != pos)
247 {
248 result.position(mark);
249 result.mark();
250 result.position(pos);
251 }
252 return result;
253 }
254
255 public ByteBuffer duplicate()
256 {
257 return duplicate(isReadOnly());
258 }
259
260 public ByteBuffer asReadOnlyBuffer()
261 {
262 return duplicate(true);
263 }
264
265 public boolean isDirect()
266 {
267 return true;
268 }
269
270 public CharBuffer asCharBuffer()
271 {
272 return new CharViewBufferImpl(this, remaining() >> 1);
273 }
274
275 public ShortBuffer asShortBuffer()
276 {
277 return new ShortViewBufferImpl(this, remaining() >> 1);
278 }
279
280 public IntBuffer asIntBuffer()
281 {
282 return new IntViewBufferImpl(this, remaining() >> 2);
283 }
284
285 public LongBuffer asLongBuffer()
286 {
287 return new LongViewBufferImpl(this, remaining() >> 3);
288 }
289
290 public FloatBuffer asFloatBuffer()
291 {
292 return new FloatViewBufferImpl(this, remaining() >> 2);
293 }
294
295 public DoubleBuffer asDoubleBuffer()
296 {
297 return new DoubleViewBufferImpl(this, remaining() >> 3);
298 }
299
300 public char getChar()
301 {
302 return ByteBufferHelper.getChar(this, order());
303 }
304
305 public ByteBuffer putChar(char value)
306 {
307 ByteBufferHelper.putChar(this, value, order());
308 return this;
309 }
310
311 public char getChar(int index)
312 {
313 return ByteBufferHelper.getChar(this, index, order());
314 }
315
316 public ByteBuffer putChar(int index, char value)
317 {
318 ByteBufferHelper.putChar(this, index, value, order());
319 return this;
320 }
321
322 public short getShort()
323 {
324 return ByteBufferHelper.getShort(this, order());
325 }
326
327 public ByteBuffer putShort(short value)
328 {
329 ByteBufferHelper.putShort(this, value, order());
330 return this;
331 }
332
333 public short getShort(int index)
334 {
335 return ByteBufferHelper.getShort(this, index, order());
336 }
337
338 public ByteBuffer putShort(int index, short value)
339 {
340 ByteBufferHelper.putShort(this, index, value, order());
341 return this;
342 }
343
344 public int getInt()
345 {
346 return ByteBufferHelper.getInt(this, order());
347 }
348
349 public ByteBuffer putInt(int value)
350 {
351 ByteBufferHelper.putInt(this, value, order());
352 return this;
353 }
354
355 public int getInt(int index)
356 {
357 return ByteBufferHelper.getInt(this, index, order());
358 }
359
360 public ByteBuffer putInt(int index, int value)
361 {
362 ByteBufferHelper.putInt(this, index, value, order());
363 return this;
364 }
365
366 public long getLong()
367 {
368 return ByteBufferHelper.getLong(this, order());
369 }
370
371 public ByteBuffer putLong(long value)
372 {
373 ByteBufferHelper.putLong(this, value, order());
374 return this;
375 }
376
377 public long getLong(int index)
378 {
379 return ByteBufferHelper.getLong(this, index, order());
380 }
381
382 public ByteBuffer putLong(int index, long value)
383 {
384 ByteBufferHelper.putLong(this, index, value, order());
385 return this;
386 }
387
388 public float getFloat()
389 {
390 return ByteBufferHelper.getFloat(this, order());
391 }
392
393 public ByteBuffer putFloat(float value)
394 {
395 ByteBufferHelper.putFloat(this, value, order());
396 return this;
397 }
398
399 public float getFloat(int index)
400 {
401 return ByteBufferHelper.getFloat(this, index, order());
402 }
403
404 public ByteBuffer putFloat(int index, float value)
405 {
406 ByteBufferHelper.putFloat(this, index, value, order());
407 return this;
408 }
409
410 public double getDouble()
411 {
412 return ByteBufferHelper.getDouble(this, order());
413 }
414
415 public ByteBuffer putDouble(double value)
416 {
417 ByteBufferHelper.putDouble(this, value, order());
418 return this;
419 }
420
421 public double getDouble(int index)
422 {
423 return ByteBufferHelper.getDouble(this, index, order());
424 }
425
426 public ByteBuffer putDouble(int index, double value)
427 {
428 ByteBufferHelper.putDouble(this, index, value, order());
429 return this;
430 }
431 }
Save This Page