1 /*
2 * Copyright (c) 2000, 2015, 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 // An object attached to this buffer. If this buffer is a view of another
62 // buffer then we use this field to keep a reference to that buffer to
63 // ensure that its memory isn't freed before we are done with it.
64 private final Object att;
65
66 public Object attachment() {
67 return att;
68 }
69
70 #if[byte]
71
72 private static class Deallocator
73 implements Runnable
74 {
75
76 private static Unsafe unsafe = Unsafe.getUnsafe();
77
78 private long address;
79 private long size;
80 private int capacity;
81
82 private Deallocator(long address, long size, int capacity) {
83 assert (address != 0);
84 this.address = address;
85 this.size = size;
86 this.capacity = capacity;
87 }
88
89 public void run() {
90 if (address == 0) {
91 // Paranoia
92 return;
93 }
94 unsafe.freeMemory(address);
95 address = 0;
96 Bits.unreserveMemory(size, capacity);
97 }
98
99 }
100
101 private final Cleaner cleaner;
102
103 public Cleaner cleaner() { return cleaner; }
104
105 #else[byte]
106
107 public Cleaner cleaner() { return null; }
108
109 #end[byte]
110
111 #end[rw]
112
113 #if[byte]
114
115 // Primary constructor
116 //
117 Direct$Type$Buffer$RW$(int cap) { // package-private
118 #if[rw]
119 super(-1, 0, cap, cap);
120 boolean pa = VM.isDirectMemoryPageAligned();
121 int ps = Bits.pageSize();
122 long size = Math.max(1L, (long)cap + (pa ? ps : 0));
123 Bits.reserveMemory(size, cap);
124
125 long base = 0;
126 try {
127 base = unsafe.allocateMemory(size);
128 } catch (OutOfMemoryError x) {
129 Bits.unreserveMemory(size, cap);
130 throw x;
131 }
132 unsafe.setMemory(base, size, (byte) 0);
133 if (pa && (base % ps != 0)) {
134 // Round up to page boundary
135 address = base + ps - (base & (ps - 1));
136 } else {
137 address = base;
138 }
139 cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
140 att = null;
141 #else[rw]
142 super(cap);
143 #end[rw]
144 }
145
146 #if[rw]
147
148 // Invoked to construct a direct ByteBuffer referring to the block of
149 // memory. A given arbitrary object may also be attached to the buffer.
150 //
151 Direct$Type$Buffer(long addr, int cap, Object ob) {
152 super(-1, 0, cap, cap);
153 address = addr;
154 cleaner = null;
155 att = ob;
156 }
157
158
159 // Invoked only by JNI: NewDirectByteBuffer(void*, long)
160 //
161 private Direct$Type$Buffer(long addr, int cap) {
162 super(-1, 0, cap, cap);
163 address = addr;
164 cleaner = null;
165 att = null;
166 }
167
168 #end[rw]
169
170 // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
171 //
172 protected Direct$Type$Buffer$RW$(int cap, long addr,
173 FileDescriptor fd,
174 Runnable unmapper)
175 {
176 #if[rw]
177 super(-1, 0, cap, cap, fd);
178 address = addr;
179 cleaner = Cleaner.create(this, unmapper);
180 att = null;
181 #else[rw]
182 super(cap, addr, fd, unmapper);
183 #end[rw]
184 }
185
186 #end[byte]
187
188 // For duplicates and slices
189 //
190 Direct$Type$Buffer$RW$$BO$(DirectBuffer db, // package-private
191 int mark, int pos, int lim, int cap,
192 int off)
193 {
194 #if[rw]
195 super(mark, pos, lim, cap);
196 address = db.address() + off;
197 #if[byte]
198 cleaner = null;
199 #end[byte]
200 att = db;
201 #else[rw]
202 super(db, mark, pos, lim, cap, off);
203 #end[rw]
204 }
205
206 public $Type$Buffer slice() {
207 int pos = this.position();
208 int lim = this.limit();
209 assert (pos <= lim);
210 int rem = (pos <= lim ? lim - pos : 0);
211 int off = (pos << $LG_BYTES_PER_VALUE$);
212 assert (off >= 0);
213 return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, off);
214 }
215
216 public $Type$Buffer duplicate() {
217 return new Direct$Type$Buffer$RW$$BO$(this,
218 this.markValue(),
219 this.position(),
220 this.limit(),
221 this.capacity(),
222 0);
223 }
224
225 public $Type$Buffer asReadOnlyBuffer() {
226 #if[rw]
227 return new Direct$Type$BufferR$BO$(this,
228 this.markValue(),
229 this.position(),
230 this.limit(),
231 this.capacity(),
232 0);
233 #else[rw]
234 return duplicate();
235 #end[rw]
236 }
237
238 #if[rw]
239
240 public long address() {
241 return address;
242 }
243
244 private long ix(int i) {
245 return address + (i << $LG_BYTES_PER_VALUE$);
246 }
247
248 public $type$ get() {
249 return $fromBits$($swap$(unsafe.get$Swaptype$(ix(nextGetIndex()))));
250 }
251
252 public $type$ get(int i) {
253 return $fromBits$($swap$(unsafe.get$Swaptype$(ix(checkIndex(i)))));
254 }
255
256 #if[streamableType]
257 $type$ getUnchecked(int i) {
258 return $fromBits$($swap$(unsafe.get$Swaptype$(ix(i))));
259 }
260 #end[streamableType]
261
262 public $Type$Buffer get($type$[] dst, int offset, int length) {
263 #if[rw]
264 if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
265 checkBounds(offset, length, dst.length);
266 int pos = position();
267 int lim = limit();
268 assert (pos <= lim);
269 int rem = (pos <= lim ? lim - pos : 0);
270 if (length > rem)
271 throw new BufferUnderflowException();
272
273 #if[!byte]
274 if (order() != ByteOrder.nativeOrder())
275 Bits.copyTo$Memtype$Array(ix(pos), dst,
276 offset << $LG_BYTES_PER_VALUE$,
277 length << $LG_BYTES_PER_VALUE$);
278 else
279 #end[!byte]
280 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
281 offset << $LG_BYTES_PER_VALUE$,
282 length << $LG_BYTES_PER_VALUE$);
283 position(pos + length);
284 } else {
285 super.get(dst, offset, length);
286 }
287 return this;
288 #else[rw]
289 throw new ReadOnlyBufferException();
290 #end[rw]
291 }
292
293 #end[rw]
294
295 public $Type$Buffer put($type$ x) {
296 #if[rw]
297 unsafe.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x)));
298 return this;
299 #else[rw]
300 throw new ReadOnlyBufferException();
301 #end[rw]
302 }
303
304 public $Type$Buffer put(int i, $type$ x) {
305 #if[rw]
306 unsafe.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x)));
307 return this;
308 #else[rw]
309 throw new ReadOnlyBufferException();
310 #end[rw]
311 }
312
313 public $Type$Buffer put($Type$Buffer src) {
314 #if[rw]
315 if (src instanceof Direct$Type$Buffer$BO$) {
316 checkSourceBufferNotThisBuffer(src);
317 Direct$Type$Buffer$RW$$BO$ sb = (Direct$Type$Buffer$RW$$BO$)src;
318
319 int spos = sb.position();
320 int slim = sb.limit();
321 assert (spos <= slim);
322 int srem = (spos <= slim ? slim - spos : 0);
323
324 int pos = position();
325 int lim = limit();
326 assert (pos <= lim);
327 int rem = (pos <= lim ? lim - pos : 0);
328
329 if (srem > rem)
330 throw new BufferOverflowException();
331 unsafe.copyMemory(sb.ix(spos), ix(pos), srem << $LG_BYTES_PER_VALUE$);
332 sb.position(spos + srem);
333 position(pos + srem);
334 } else if (src.hb != null) {
335
336 int spos = src.position();
337 int slim = src.limit();
338 assert (spos <= slim);
339 int srem = (spos <= slim ? slim - spos : 0);
340
341 put(src.hb, src.offset + spos, srem);
342 src.position(spos + srem);
343
344 } else {
345 super.put(src);
346 }
347 return this;
348 #else[rw]
349 throw new ReadOnlyBufferException();
350 #end[rw]
351 }
352
353 public $Type$Buffer put($type$[] src, int offset, int length) {
354 #if[rw]
355 if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
356 checkBounds(offset, length, src.length);
357 int pos = position();
358 int lim = limit();
359 assert (pos <= lim);
360 int rem = (pos <= lim ? lim - pos : 0);
361 if (length > rem)
362 throw new BufferOverflowException();
363
364 #if[!byte]
365 if (order() != ByteOrder.nativeOrder())
366 Bits.copyFrom$Memtype$Array(src, offset << $LG_BYTES_PER_VALUE$,
367 ix(pos), length << $LG_BYTES_PER_VALUE$);
368 else
369 #end[!byte]
370 Bits.copyFromArray(src, arrayBaseOffset, offset << $LG_BYTES_PER_VALUE$,
371 ix(pos), length << $LG_BYTES_PER_VALUE$);
372 position(pos + length);
373 } else {
374 super.put(src, offset, length);
375 }
376 return this;
377 #else[rw]
378 throw new ReadOnlyBufferException();
379 #end[rw]
380 }
381
382 public $Type$Buffer compact() {
383 #if[rw]
384 int pos = position();
385 int lim = limit();
386 assert (pos <= lim);
387 int rem = (pos <= lim ? lim - pos : 0);
388
389 unsafe.copyMemory(ix(pos), ix(0), rem << $LG_BYTES_PER_VALUE$);
390 position(rem);
391 limit(capacity());
392 discardMark();
393 return this;
394 #else[rw]
395 throw new ReadOnlyBufferException();
396 #end[rw]
397 }
398
399 public boolean isDirect() {
400 return true;
401 }
402
403 public boolean isReadOnly() {
404 return {#if[rw]?false:true};
405 }
406
407
408 #if[char]
409
410 public String toString(int start, int end) {
411 if ((end > limit()) || (start > end))
412 throw new IndexOutOfBoundsException();
413 try {
414 int len = end - start;
415 char[] ca = new char[len];
416 CharBuffer cb = CharBuffer.wrap(ca);
417 CharBuffer db = this.duplicate();
418 db.position(start);
419 db.limit(end);
420 cb.put(db);
421 return new String(ca);
422 } catch (StringIndexOutOfBoundsException x) {
423 throw new IndexOutOfBoundsException();
424 }
425 }
426
427
428 // --- Methods to support CharSequence ---
429
430 public CharBuffer subSequence(int start, int end) {
431 int pos = position();
432 int lim = limit();
433 assert (pos <= lim);
434 pos = (pos <= lim ? pos : lim);
435 int len = lim - pos;
436
437 if ((start < 0) || (end > len) || (start > end))
438 throw new IndexOutOfBoundsException();
439 return new DirectCharBuffer$RW$$BO$(this,
440 -1,
441 pos + start,
442 pos + end,
443 capacity(),
444 offset);
445 }
446
447 #end[char]
448
449
450
451 #if[!byte]
452
453 public ByteOrder order() {
454 #if[boS]
455 return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
456 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
457 #end[boS]
458 #if[boU]
459 return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
460 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
461 #end[boU]
462 }
463
464 #end[!byte]
465
466
467
468 #if[byte]
469
470 byte _get(int i) { // package-private
471 return unsafe.getByte(address + i);
472 }
473
474 void _put(int i, byte b) { // package-private
475 #if[rw]
476 unsafe.putByte(address + i, b);
477 #else[rw]
478 throw new ReadOnlyBufferException();
479 #end[rw]
480 }
481
482 // #BIN
483 //
484 // Binary-data access methods for short, char, int, long, float,
485 // and double will be inserted here
486
487 #end[byte]
488
489 }