KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > java > nio > DirectDoubleBufferS


1 /*
2  * @(#)Direct-X-Buffer.java 1.48 04/05/03
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */

7
8 // -- This file was mechanically generated: Do not edit! -- //
9

10 package java.nio;
11
12 import sun.misc.Cleaner;
13 import sun.misc.Unsafe;
14 import sun.nio.ch.DirectBuffer;
15 import sun.nio.ch.FileChannelImpl;
16
17
18 class DirectDoubleBufferS
19
20     extends DoubleBuffer JavaDoc
21
22
23
24     implements DirectBuffer
25 {
26
27
28
29     // Cached unsafe-access object
30
protected static final Unsafe unsafe = Bits.unsafe();
31
32     // Cached unaligned-access capability
33
protected static final boolean unaligned = Bits.unaligned();
34
35     // Base address, used in all indexing calculations
36
// NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
37
// protected long address;
38

39     // If this buffer is a view of another buffer then we keep a reference to
40
// that buffer so that its memory isn't freed before we're done with it
41
protected Object JavaDoc viewedBuffer = null;
42
43     public Object JavaDoc viewedBuffer() {
44         return viewedBuffer;
45     }
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82     public Cleaner cleaner() { return null; }
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144     // For duplicates and slices
145
//
146
DirectDoubleBufferS(DirectBuffer db, // package-private
147
int mark, int pos, int lim, int cap,
148                    int off)
149     {
150
151     super(mark, pos, lim, cap);
152     address = db.address() + off;
153     viewedBuffer = db;
154
155
156
157
158
159
160     }
161
162     public DoubleBuffer JavaDoc slice() {
163     int pos = this.position();
164     int lim = this.limit();
165     assert (pos <= lim);
166     int rem = (pos <= lim ? lim - pos : 0);
167     int off = (pos << 3);
168         assert (off >= 0);
169     return new DirectDoubleBufferS JavaDoc(this, -1, 0, rem, rem, off);
170     }
171
172     public DoubleBuffer JavaDoc duplicate() {
173     return new DirectDoubleBufferS JavaDoc(this,
174                           this.markValue(),
175                           this.position(),
176                           this.limit(),
177                           this.capacity(),
178                           0);
179     }
180
181     public DoubleBuffer JavaDoc asReadOnlyBuffer() {
182
183     return new DirectDoubleBufferRS JavaDoc(this,
184                        this.markValue(),
185                        this.position(),
186                        this.limit(),
187                        this.capacity(),
188                        0);
189
190
191
192     }
193
194
195
196     public long address() {
197     return address;
198     }
199
200     private long ix(int i) {
201         return address + (i << 3);
202     }
203
204     public double get() {
205     return Double.longBitsToDouble(Bits.swap(unsafe.getLong(ix(nextGetIndex()))));
206     }
207
208     public double get(int i) {
209     return Double.longBitsToDouble(Bits.swap(unsafe.getLong(ix(checkIndex(i)))));
210     }
211
212     public DoubleBuffer JavaDoc get(double[] dst, int offset, int length) {
213
214     if ((length << 3) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
215         checkBounds(offset, length, dst.length);
216         int pos = position();
217         int lim = limit();
218         assert (pos <= lim);
219         int rem = (pos <= lim ? lim - pos : 0);
220         if (length > rem)
221         throw new BufferUnderflowException JavaDoc();
222
223         if (order() != ByteOrder.nativeOrder())
224         Bits.copyToLongArray(ix(pos), dst,
225                       offset << 3,
226                       length << 3);
227         else
228         Bits.copyToByteArray(ix(pos), dst,
229                      offset << 3,
230                      length << 3);
231         position(pos + length);
232     } else {
233         super.get(dst, offset, length);
234     }
235     return this;
236
237
238
239     }
240
241
242
243     public DoubleBuffer JavaDoc put(double x) {
244
245     unsafe.putLong(ix(nextPutIndex()), Bits.swap(Double.doubleToRawLongBits(x)));
246     return this;
247
248
249
250     }
251
252     public DoubleBuffer JavaDoc put(int i, double x) {
253
254     unsafe.putLong(ix(checkIndex(i)), Bits.swap(Double.doubleToRawLongBits(x)));
255     return this;
256
257
258
259     }
260
261     public DoubleBuffer JavaDoc put(DoubleBuffer JavaDoc src) {
262
263     if (src instanceof DirectDoubleBufferS JavaDoc) {
264         if (src == this)
265         throw new IllegalArgumentException JavaDoc();
266         DirectDoubleBufferS JavaDoc sb = (DirectDoubleBufferS JavaDoc)src;
267
268         int spos = sb.position();
269         int slim = sb.limit();
270         assert (spos <= slim);
271         int srem = (spos <= slim ? slim - spos : 0);
272
273         int pos = position();
274         int lim = limit();
275         assert (pos <= lim);
276         int rem = (pos <= lim ? lim - pos : 0);
277
278         if (srem > rem)
279         throw new BufferOverflowException JavaDoc();
280         unsafe.copyMemory(sb.ix(spos), ix(pos), srem << 3);
281         sb.position(spos + srem);
282         position(pos + srem);
283     } else if (!src.isDirect()) {
284
285         int spos = src.position();
286         int slim = src.limit();
287         assert (spos <= slim);
288         int srem = (spos <= slim ? slim - spos : 0);
289
290         put(src.hb, src.offset + spos, srem);
291         src.position(spos + srem);
292
293     } else {
294         super.put(src);
295     }
296     return this;
297
298
299
300     }
301
302     public DoubleBuffer JavaDoc put(double[] src, int offset, int length) {
303
304     if ((length << 3) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
305         checkBounds(offset, length, src.length);
306         int pos = position();
307         int lim = limit();
308         assert (pos <= lim);
309         int rem = (pos <= lim ? lim - pos : 0);
310         if (length > rem)
311         throw new BufferOverflowException JavaDoc();
312
313         if (order() != ByteOrder.nativeOrder())
314         Bits.copyFromLongArray(src, offset << 3,
315                         ix(pos), length << 3);
316         else
317         Bits.copyFromByteArray(src, offset << 3,
318                        ix(pos), length << 3);
319         position(pos + length);
320     } else {
321         super.put(src, offset, length);
322     }
323     return this;
324
325
326
327     }
328     
329     public DoubleBuffer JavaDoc compact() {
330
331     int pos = position();
332     int lim = limit();
333     assert (pos <= lim);
334     int rem = (pos <= lim ? lim - pos : 0);
335
336     unsafe.copyMemory(ix(pos), ix(0), rem << 3);
337     position(rem);
338     limit(capacity());
339     return this;
340
341
342
343     }
344
345     public boolean isDirect() {
346     return true;
347     }
348
349     public boolean isReadOnly() {
350     return false;
351     }
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397     public ByteOrder JavaDoc order() {
398
399     return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
400         ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
401
402
403
404
405
406     }
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433 }
434
Popular Tags