1 /*
2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #warn This file is preprocessed before being compiled
27
28 package java.nio;
29
30 import java.io.FileDescriptor;
31 import sun.misc.Cleaner;
32 import sun.misc.Unsafe;
33 import sun.misc.VM;
34 import sun.nio.ch.DirectBuffer;
35
36
37 class Direct$Type$Buffer$RW$$BO$
38 #if[rw]
39 extends {#if[byte]?Mapped$Type$Buffer:$Type$Buffer}
40 #else[rw]
41 extends Direct$Type$Buffer$BO$
42 #end[rw]
43 implements DirectBuffer
44 {
45
46 #if[rw]
47
48 // Cached unsafe-access object
49 protected static final Unsafe unsafe = Bits.unsafe();
50
51 // Cached array base offset
52 private static final long arrayBaseOffset = (long)unsafe.arrayBaseOffset($type$[].class);
53
54 // Cached unaligned-access capability
55 protected static final boolean unaligned = Bits.unaligned();
56
57 // Base address, used in all indexing calculations
58 // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
59 // protected long address;
60
61 // If this buffer is a view of another buffer then we keep a reference to
62 // that buffer so that its memory isn't freed before we're done with it
63 protected Object viewedBuffer = null;
64
65 public Object viewedBuffer() {
66 return viewedBuffer;
67 }
68
69 #if[byte]
70
71 private static class Deallocator
72 implements Runnable
73 {
74
75 private static Unsafe unsafe = Unsafe.getUnsafe();
76
77 private long address;
78 private long size;
79 private int capacity;
80
81 private Deallocator(long address, long size, int capacity) {
82 assert (address != 0);
83 this.address = address;
84 this.size = size;
85 this.capacity = capacity;
86 }
87
88 public void run() {
89 if (address == 0) {
90 // Paranoia
91 return;
92 }
93 unsafe.freeMemory(address);
94 address = 0;
95 Bits.unreserveMemory(size, capacity);
96 }
97
98 }
99
100 private final Cleaner cleaner;
101
102 public Cleaner cleaner() { return cleaner; }
103
104 #else[byte]
105
106 public Cleaner cleaner() { return null; }
107
108 #end[byte]
109
110 #end[rw]
111
112 #if[byte]
113
114 // Primary constructor
115 //
116 Direct$Type$Buffer$RW$(int cap) { // package-private
117 #if[rw]
118 super(-1, 0, cap, cap);
119 boolean pa = VM.isDirectMemoryPageAligned();
120 int ps = Bits.pageSize();
121 long size = Math.max(1L, (long)cap + (pa ? ps : 0));
122 Bits.reserveMemory(size, cap);
123
124 long base = 0;
125 try {
126 base = unsafe.allocateMemory(size);
127 } catch (OutOfMemoryError x) {
128 Bits.unreserveMemory(size, cap);
129 throw x;
130 }
131 unsafe.setMemory(base, size, (byte) 0);
132 if (pa && (base % ps != 0)) {
133 // Round up to page boundary
134 address = base + ps - (base & (ps - 1));
135 } else {
136 address = base;
137 }
138 cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
139 #else[rw]
140 super(cap);
141 #end[rw]
142 }
143
144 #if[rw]
145
146 // Invoked only by JNI: NewDirectByteBuffer(void*, long)
147 //
148 private Direct$Type$Buffer(long addr, int cap) {
149 super(-1, 0, cap, cap);
150 address = addr;
151 cleaner = null;
152 }
153
154 #end[rw]
155
156 // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
157 //
158 protected Direct$Type$Buffer$RW$(int cap, long addr,
159 FileDescriptor fd,
160 Runnable unmapper)
161 {
162 #if[rw]
163 super(-1, 0, cap, cap, fd);
164 address = addr;
165 viewedBuffer = null;
166 cleaner = Cleaner.create(this, unmapper);
167 #else[rw]
168 super(cap, addr, fd, unmapper);
169 #end[rw]
170 }
171
172 #end[byte]
173
174 // For duplicates and slices
175 //
176 Direct$Type$Buffer$RW$$BO$(DirectBuffer db, // package-private
177 int mark, int pos, int lim, int cap,
178 int off)
179 {
180 #if[rw]
181 super(mark, pos, lim, cap);
182 address = db.address() + off;
183 viewedBuffer = db;
184 #if[byte]
185 cleaner = null;
186 #end[byte]
187 #else[rw]
188 super(db, mark, pos, lim, cap, off);
189 #end[rw]
190 }
191
192 public $Type$Buffer slice() {
193 int pos = this.position();
194 int lim = this.limit();
195 assert (pos <= lim);
196 int rem = (pos <= lim ? lim - pos : 0);
197 int off = (pos << $LG_BYTES_PER_VALUE$);
198 assert (off >= 0);
199 return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, off);
200 }
201
202 public $Type$Buffer duplicate() {
203 return new Direct$Type$Buffer$RW$$BO$(this,
204 this.markValue(),
205 this.position(),
206 this.limit(),
207 this.capacity(),
208 0);
209 }
210
211 public $Type$Buffer asReadOnlyBuffer() {
212 #if[rw]
213 return new Direct$Type$BufferR$BO$(this,
214 this.markValue(),
215 this.position(),
216 this.limit(),
217 this.capacity(),
218 0);
219 #else[rw]
220 return duplicate();
221 #end[rw]
222 }
223
224 #if[rw]
225
226 public long address() {
227 return address;
228 }
229
230 private long ix(int i) {
231 return address + (i << $LG_BYTES_PER_VALUE$);
232 }
233
234 public $type$ get() {
235 return $fromBits$($swap$(unsafe.get$Swaptype$(ix(nextGetIndex()))));
236 }
237
238 public $type$ get(int i) {
239 return $fromBits$($swap$(unsafe.get$Swaptype$(ix(checkIndex(i)))));
240 }
241
242 public $Type$Buffer get($type$[] dst, int offset, int length) {
243 #if[rw]
244 if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
245 checkBounds(offset, length, dst.length);
246 int pos = position();
247 int lim = limit();
248 assert (pos <= lim);
249 int rem = (pos <= lim ? lim - pos : 0);
250 if (length > rem)
251 throw new BufferUnderflowException();
252
253 #if[!byte]
254 if (order() != ByteOrder.nativeOrder())
255 Bits.copyTo$Memtype$Array(ix(pos), dst,
256 offset << $LG_BYTES_PER_VALUE$,
257 length << $LG_BYTES_PER_VALUE$);
258 else
259 #end[!byte]
260 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261 offset << $LG_BYTES_PER_VALUE$,
262 length << $LG_BYTES_PER_VALUE$);
263 position(pos + length);
264 } else {
265 super.get(dst, offset, length);
266 }
267 return this;
268 #else[rw]
269 throw new ReadOnlyBufferException();
270 #end[rw]
271 }
272
273 #end[rw]
274
275 public $Type$Buffer put($type$ x) {
276 #if[rw]
277 unsafe.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x)));
278 return this;
279 #else[rw]
280 throw new ReadOnlyBufferException();
281 #end[rw]
282 }
283
284 public $Type$Buffer put(int i, $type$ x) {
285 #if[rw]
286 unsafe.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x)));
287 return this;
288 #else[rw]
289 throw new ReadOnlyBufferException();
290 #end[rw]
291 }
292
293 public $Type$Buffer put($Type$Buffer src) {
294 #if[rw]
295 if (src instanceof Direct$Type$Buffer$BO$) {
296 if (src == this)
297 throw new IllegalArgumentException();
298 Direct$Type$Buffer$RW$$BO$ sb = (Direct$Type$Buffer$RW$$BO$)src;
299
300 int spos = sb.position();
301 int slim = sb.limit();
302 assert (spos <= slim);
303 int srem = (spos <= slim ? slim - spos : 0);
304
305 int pos = position();
306 int lim = limit();
307 assert (pos <= lim);
308 int rem = (pos <= lim ? lim - pos : 0);
309
310 if (srem > rem)
311 throw new BufferOverflowException();
312 unsafe.copyMemory(sb.ix(spos), ix(pos), srem << $LG_BYTES_PER_VALUE$);
313 sb.position(spos + srem);
314 position(pos + srem);
315 } else if (src.hb != null) {
316
317 int spos = src.position();
318 int slim = src.limit();
319 assert (spos <= slim);
320 int srem = (spos <= slim ? slim - spos : 0);
321
322 put(src.hb, src.offset + spos, srem);
323 src.position(spos + srem);
324
325 } else {
326 super.put(src);
327 }
328 return this;
329 #else[rw]
330 throw new ReadOnlyBufferException();
331 #end[rw]
332 }
333
334 public $Type$Buffer put($type$[] src, int offset, int length) {
335 #if[rw]
336 if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
337 checkBounds(offset, length, src.length);
338 int pos = position();
339 int lim = limit();
340 assert (pos <= lim);
341 int rem = (pos <= lim ? lim - pos : 0);
342 if (length > rem)
343 throw new BufferOverflowException();
344
345 #if[!byte]
346 if (order() != ByteOrder.nativeOrder())
347 Bits.copyFrom$Memtype$Array(src, offset << $LG_BYTES_PER_VALUE$,
348 ix(pos), length << $LG_BYTES_PER_VALUE$);
349 else
350 #end[!byte]
351 Bits.copyFromArray(src, arrayBaseOffset, offset << $LG_BYTES_PER_VALUE$,
352 ix(pos), length << $LG_BYTES_PER_VALUE$);
353 position(pos + length);
354 } else {
355 super.put(src, offset, length);
356 }
357 return this;
358 #else[rw]
359 throw new ReadOnlyBufferException();
360 #end[rw]
361 }
362
363 public $Type$Buffer compact() {
364 #if[rw]
365 int pos = position();
366 int lim = limit();
367 assert (pos <= lim);
368 int rem = (pos <= lim ? lim - pos : 0);
369
370 unsafe.copyMemory(ix(pos), ix(0), rem << $LG_BYTES_PER_VALUE$);
371 position(rem);
372 limit(capacity());
373 discardMark();
374 return this;
375 #else[rw]
376 throw new ReadOnlyBufferException();
377 #end[rw]
378 }
379
380 public boolean isDirect() {
381 return true;
382 }
383
384 public boolean isReadOnly() {
385 return {#if[rw]?false:true};
386 }
387
388
389 #if[char]
390
391 public String toString(int start, int end) {
392 if ((end > limit()) || (start > end))
393 throw new IndexOutOfBoundsException();
394 try {
395 int len = end - start;
396 char[] ca = new char[len];
397 CharBuffer cb = CharBuffer.wrap(ca);
398 CharBuffer db = this.duplicate();
399 db.position(start);
400 db.limit(end);
401 cb.put(db);
402 return new String(ca);
403 } catch (StringIndexOutOfBoundsException x) {
404 throw new IndexOutOfBoundsException();
405 }
406 }
407
408
409 // --- Methods to support CharSequence ---
410
411 public CharBuffer subSequence(int start, int end) {
412 int pos = position();
413 int lim = limit();
414 assert (pos <= lim);
415 pos = (pos <= lim ? pos : lim);
416 int len = lim - pos;
417
418 if ((start < 0) || (end > len) || (start > end))
419 throw new IndexOutOfBoundsException();
420 return new DirectCharBuffer$RW$$BO$(this,
421 -1,
422 pos + start,
423 pos + end,
424 capacity(),
425 offset);
426 }
427
428 #end[char]
429
430
431
432 #if[!byte]
433
434 public ByteOrder order() {
435 #if[boS]
436 return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438 #end[boS]
439 #if[boU]
440 return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
441 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
442 #end[boU]
443 }
444
445 #end[!byte]
446
447
448
449 #if[byte]
450
451 byte _get(int i) { // package-private
452 return unsafe.getByte(address + i);
453 }
454
455 void _put(int i, byte b) { // package-private
456 #if[rw]
457 unsafe.putByte(address + i, b);
458 #else[rw]
459 throw new ReadOnlyBufferException();
460 #end[rw]
461 }
462
463 // #BIN
464 //
465 // Binary-data access methods for short, char, int, long, float,
466 // and double will be inserted here
467
468 #end[byte]
469
470 }