History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/nio/Direct-X-Buffer.java.template (1 of 18352 files). Show all

Unified · Split

java/pkg/java/nio/Direct-X-Buffer.java.template+470−0
@@ -0,0 +1,470 @@
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+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t