1 /* |
|
2 * Copyright 2000-2008 Sun Microsystems, Inc. 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. Sun designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
22 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
23 * have any questions. |
|
24 */ |
|
25 |
|
26 #warn This file is preprocessed before being compiled |
|
27 |
|
28 package java.nio; |
|
29 |
|
30 |
|
31 /** |
|
32 #if[rw] |
|
33 * A read/write Heap$Type$Buffer. |
|
34 #else[rw] |
|
35 * A read-only Heap$Type$Buffer. This class extends the corresponding |
|
36 * read/write class, overriding the mutation methods to throw a {@link |
|
37 * ReadOnlyBufferException} and overriding the view-buffer methods to return an |
|
38 * instance of this class rather than of the superclass. |
|
39 #end[rw] |
|
40 */ |
|
41 |
|
42 class Heap$Type$Buffer$RW$ |
|
43 extends {#if[ro]?Heap}$Type$Buffer |
|
44 { |
|
45 |
|
46 // For speed these fields are actually declared in X-Buffer; |
|
47 // these declarations are here as documentation |
|
48 /* |
|
49 #if[rw] |
|
50 protected final $type$[] hb; |
|
51 protected final int offset; |
|
52 #end[rw] |
|
53 */ |
|
54 |
|
55 Heap$Type$Buffer$RW$(int cap, int lim) { // package-private |
|
56 #if[rw] |
|
57 super(-1, 0, lim, cap, new $type$[cap], 0); |
|
58 /* |
|
59 hb = new $type$[cap]; |
|
60 offset = 0; |
|
61 */ |
|
62 #else[rw] |
|
63 super(cap, lim); |
|
64 this.isReadOnly = true; |
|
65 #end[rw] |
|
66 } |
|
67 |
|
68 Heap$Type$Buffer$RW$($type$[] buf, int off, int len) { // package-private |
|
69 #if[rw] |
|
70 super(-1, off, off + len, buf.length, buf, 0); |
|
71 /* |
|
72 hb = buf; |
|
73 offset = 0; |
|
74 */ |
|
75 #else[rw] |
|
76 super(buf, off, len); |
|
77 this.isReadOnly = true; |
|
78 #end[rw] |
|
79 } |
|
80 |
|
81 protected Heap$Type$Buffer$RW$($type$[] buf, |
|
82 int mark, int pos, int lim, int cap, |
|
83 int off) |
|
84 { |
|
85 #if[rw] |
|
86 super(mark, pos, lim, cap, buf, off); |
|
87 /* |
|
88 hb = buf; |
|
89 offset = off; |
|
90 */ |
|
91 #else[rw] |
|
92 super(buf, mark, pos, lim, cap, off); |
|
93 this.isReadOnly = true; |
|
94 #end[rw] |
|
95 } |
|
96 |
|
97 public $Type$Buffer slice() { |
|
98 return new Heap$Type$Buffer$RW$(hb, |
|
99 -1, |
|
100 0, |
|
101 this.remaining(), |
|
102 this.remaining(), |
|
103 this.position() + offset); |
|
104 } |
|
105 |
|
106 public $Type$Buffer duplicate() { |
|
107 return new Heap$Type$Buffer$RW$(hb, |
|
108 this.markValue(), |
|
109 this.position(), |
|
110 this.limit(), |
|
111 this.capacity(), |
|
112 offset); |
|
113 } |
|
114 |
|
115 public $Type$Buffer asReadOnlyBuffer() { |
|
116 #if[rw] |
|
117 return new Heap$Type$BufferR(hb, |
|
118 this.markValue(), |
|
119 this.position(), |
|
120 this.limit(), |
|
121 this.capacity(), |
|
122 offset); |
|
123 #else[rw] |
|
124 return duplicate(); |
|
125 #end[rw] |
|
126 } |
|
127 |
|
128 #if[rw] |
|
129 |
|
130 protected int ix(int i) { |
|
131 return i + offset; |
|
132 } |
|
133 |
|
134 public $type$ get() { |
|
135 return hb[ix(nextGetIndex())]; |
|
136 } |
|
137 |
|
138 public $type$ get(int i) { |
|
139 return hb[ix(checkIndex(i))]; |
|
140 } |
|
141 |
|
142 public $Type$Buffer get($type$[] dst, int offset, int length) { |
|
143 checkBounds(offset, length, dst.length); |
|
144 if (length > remaining()) |
|
145 throw new BufferUnderflowException(); |
|
146 System.arraycopy(hb, ix(position()), dst, offset, length); |
|
147 position(position() + length); |
|
148 return this; |
|
149 } |
|
150 |
|
151 public boolean isDirect() { |
|
152 return false; |
|
153 } |
|
154 |
|
155 #end[rw] |
|
156 |
|
157 public boolean isReadOnly() { |
|
158 return {#if[rw]?false:true}; |
|
159 } |
|
160 |
|
161 public $Type$Buffer put($type$ x) { |
|
162 #if[rw] |
|
163 hb[ix(nextPutIndex())] = x; |
|
164 return this; |
|
165 #else[rw] |
|
166 throw new ReadOnlyBufferException(); |
|
167 #end[rw] |
|
168 } |
|
169 |
|
170 public $Type$Buffer put(int i, $type$ x) { |
|
171 #if[rw] |
|
172 hb[ix(checkIndex(i))] = x; |
|
173 return this; |
|
174 #else[rw] |
|
175 throw new ReadOnlyBufferException(); |
|
176 #end[rw] |
|
177 } |
|
178 |
|
179 public $Type$Buffer put($type$[] src, int offset, int length) { |
|
180 #if[rw] |
|
181 checkBounds(offset, length, src.length); |
|
182 if (length > remaining()) |
|
183 throw new BufferOverflowException(); |
|
184 System.arraycopy(src, offset, hb, ix(position()), length); |
|
185 position(position() + length); |
|
186 return this; |
|
187 #else[rw] |
|
188 throw new ReadOnlyBufferException(); |
|
189 #end[rw] |
|
190 } |
|
191 |
|
192 public $Type$Buffer put($Type$Buffer src) { |
|
193 #if[rw] |
|
194 if (src instanceof Heap$Type$Buffer) { |
|
195 if (src == this) |
|
196 throw new IllegalArgumentException(); |
|
197 Heap$Type$Buffer sb = (Heap$Type$Buffer)src; |
|
198 int n = sb.remaining(); |
|
199 if (n > remaining()) |
|
200 throw new BufferOverflowException(); |
|
201 System.arraycopy(sb.hb, sb.ix(sb.position()), |
|
202 hb, ix(position()), n); |
|
203 sb.position(sb.position() + n); |
|
204 position(position() + n); |
|
205 } else if (src.isDirect()) { |
|
206 int n = src.remaining(); |
|
207 if (n > remaining()) |
|
208 throw new BufferOverflowException(); |
|
209 src.get(hb, ix(position()), n); |
|
210 position(position() + n); |
|
211 } else { |
|
212 super.put(src); |
|
213 } |
|
214 return this; |
|
215 #else[rw] |
|
216 throw new ReadOnlyBufferException(); |
|
217 #end[rw] |
|
218 } |
|
219 |
|
220 public $Type$Buffer compact() { |
|
221 #if[rw] |
|
222 System.arraycopy(hb, ix(position()), hb, ix(0), remaining()); |
|
223 position(remaining()); |
|
224 limit(capacity()); |
|
225 discardMark(); |
|
226 return this; |
|
227 #else[rw] |
|
228 throw new ReadOnlyBufferException(); |
|
229 #end[rw] |
|
230 } |
|
231 |
|
232 |
|
233 |
|
234 #if[byte] |
|
235 |
|
236 byte _get(int i) { // package-private |
|
237 return hb[i]; |
|
238 } |
|
239 |
|
240 void _put(int i, byte b) { // package-private |
|
241 #if[rw] |
|
242 hb[i] = b; |
|
243 #else[rw] |
|
244 throw new ReadOnlyBufferException(); |
|
245 #end[rw] |
|
246 } |
|
247 |
|
248 // char |
|
249 |
|
250 #if[rw] |
|
251 |
|
252 public char getChar() { |
|
253 return Bits.getChar(this, ix(nextGetIndex(2)), bigEndian); |
|
254 } |
|
255 |
|
256 public char getChar(int i) { |
|
257 return Bits.getChar(this, ix(checkIndex(i, 2)), bigEndian); |
|
258 } |
|
259 |
|
260 #end[rw] |
|
261 |
|
262 public $Type$Buffer putChar(char x) { |
|
263 #if[rw] |
|
264 Bits.putChar(this, ix(nextPutIndex(2)), x, bigEndian); |
|
265 return this; |
|
266 #else[rw] |
|
267 throw new ReadOnlyBufferException(); |
|
268 #end[rw] |
|
269 } |
|
270 |
|
271 public $Type$Buffer putChar(int i, char x) { |
|
272 #if[rw] |
|
273 Bits.putChar(this, ix(checkIndex(i, 2)), x, bigEndian); |
|
274 return this; |
|
275 #else[rw] |
|
276 throw new ReadOnlyBufferException(); |
|
277 #end[rw] |
|
278 } |
|
279 |
|
280 public CharBuffer asCharBuffer() { |
|
281 int size = this.remaining() >> 1; |
|
282 int off = offset + position(); |
|
283 return (bigEndian |
|
284 ? (CharBuffer)(new ByteBufferAsCharBuffer$RW$B(this, |
|
285 -1, |
|
286 0, |
|
287 size, |
|
288 size, |
|
289 off)) |
|
290 : (CharBuffer)(new ByteBufferAsCharBuffer$RW$L(this, |
|
291 -1, |
|
292 0, |
|
293 size, |
|
294 size, |
|
295 off))); |
|
296 } |
|
297 |
|
298 |
|
299 // short |
|
300 |
|
301 #if[rw] |
|
302 |
|
303 public short getShort() { |
|
304 return Bits.getShort(this, ix(nextGetIndex(2)), bigEndian); |
|
305 } |
|
306 |
|
307 public short getShort(int i) { |
|
308 return Bits.getShort(this, ix(checkIndex(i, 2)), bigEndian); |
|
309 } |
|
310 |
|
311 #end[rw] |
|
312 |
|
313 public $Type$Buffer putShort(short x) { |
|
314 #if[rw] |
|
315 Bits.putShort(this, ix(nextPutIndex(2)), x, bigEndian); |
|
316 return this; |
|
317 #else[rw] |
|
318 throw new ReadOnlyBufferException(); |
|
319 #end[rw] |
|
320 } |
|
321 |
|
322 public $Type$Buffer putShort(int i, short x) { |
|
323 #if[rw] |
|
324 Bits.putShort(this, ix(checkIndex(i, 2)), x, bigEndian); |
|
325 return this; |
|
326 #else[rw] |
|
327 throw new ReadOnlyBufferException(); |
|
328 #end[rw] |
|
329 } |
|
330 |
|
331 public ShortBuffer asShortBuffer() { |
|
332 int size = this.remaining() >> 1; |
|
333 int off = offset + position(); |
|
334 return (bigEndian |
|
335 ? (ShortBuffer)(new ByteBufferAsShortBuffer$RW$B(this, |
|
336 -1, |
|
337 0, |
|
338 size, |
|
339 size, |
|
340 off)) |
|
341 : (ShortBuffer)(new ByteBufferAsShortBuffer$RW$L(this, |
|
342 -1, |
|
343 0, |
|
344 size, |
|
345 size, |
|
346 off))); |
|
347 } |
|
348 |
|
349 |
|
350 // int |
|
351 |
|
352 #if[rw] |
|
353 |
|
354 public int getInt() { |
|
355 return Bits.getInt(this, ix(nextGetIndex(4)), bigEndian); |
|
356 } |
|
357 |
|
358 public int getInt(int i) { |
|
359 return Bits.getInt(this, ix(checkIndex(i, 4)), bigEndian); |
|
360 } |
|
361 |
|
362 #end[rw] |
|
363 |
|
364 public $Type$Buffer putInt(int x) { |
|
365 #if[rw] |
|
366 Bits.putInt(this, ix(nextPutIndex(4)), x, bigEndian); |
|
367 return this; |
|
368 #else[rw] |
|
369 throw new ReadOnlyBufferException(); |
|
370 #end[rw] |
|
371 } |
|
372 |
|
373 public $Type$Buffer putInt(int i, int x) { |
|
374 #if[rw] |
|
375 Bits.putInt(this, ix(checkIndex(i, 4)), x, bigEndian); |
|
376 return this; |
|
377 #else[rw] |
|
378 throw new ReadOnlyBufferException(); |
|
379 #end[rw] |
|
380 } |
|
381 |
|
382 public IntBuffer asIntBuffer() { |
|
383 int size = this.remaining() >> 2; |
|
384 int off = offset + position(); |
|
385 return (bigEndian |
|
386 ? (IntBuffer)(new ByteBufferAsIntBuffer$RW$B(this, |
|
387 -1, |
|
388 0, |
|
389 size, |
|
390 size, |
|
391 off)) |
|
392 : (IntBuffer)(new ByteBufferAsIntBuffer$RW$L(this, |
|
393 -1, |
|
394 0, |
|
395 size, |
|
396 size, |
|
397 off))); |
|
398 } |
|
399 |
|
400 |
|
401 // long |
|
402 |
|
403 #if[rw] |
|
404 |
|
405 public long getLong() { |
|
406 return Bits.getLong(this, ix(nextGetIndex(8)), bigEndian); |
|
407 } |
|
408 |
|
409 public long getLong(int i) { |
|
410 return Bits.getLong(this, ix(checkIndex(i, 8)), bigEndian); |
|
411 } |
|
412 |
|
413 #end[rw] |
|
414 |
|
415 public $Type$Buffer putLong(long x) { |
|
416 #if[rw] |
|
417 Bits.putLong(this, ix(nextPutIndex(8)), x, bigEndian); |
|
418 return this; |
|
419 #else[rw] |
|
420 throw new ReadOnlyBufferException(); |
|
421 #end[rw] |
|
422 } |
|
423 |
|
424 public $Type$Buffer putLong(int i, long x) { |
|
425 #if[rw] |
|
426 Bits.putLong(this, ix(checkIndex(i, 8)), x, bigEndian); |
|
427 return this; |
|
428 #else[rw] |
|
429 throw new ReadOnlyBufferException(); |
|
430 #end[rw] |
|
431 } |
|
432 |
|
433 public LongBuffer asLongBuffer() { |
|
434 int size = this.remaining() >> 3; |
|
435 int off = offset + position(); |
|
436 return (bigEndian |
|
437 ? (LongBuffer)(new ByteBufferAsLongBuffer$RW$B(this, |
|
438 -1, |
|
439 0, |
|
440 size, |
|
441 size, |
|
442 off)) |
|
443 : (LongBuffer)(new ByteBufferAsLongBuffer$RW$L(this, |
|
444 -1, |
|
445 0, |
|
446 size, |
|
447 size, |
|
448 off))); |
|
449 } |
|
450 |
|
451 |
|
452 // float |
|
453 |
|
454 #if[rw] |
|
455 |
|
456 public float getFloat() { |
|
457 return Bits.getFloat(this, ix(nextGetIndex(4)), bigEndian); |
|
458 } |
|
459 |
|
460 public float getFloat(int i) { |
|
461 return Bits.getFloat(this, ix(checkIndex(i, 4)), bigEndian); |
|
462 } |
|
463 |
|
464 #end[rw] |
|
465 |
|
466 public $Type$Buffer putFloat(float x) { |
|
467 #if[rw] |
|
468 Bits.putFloat(this, ix(nextPutIndex(4)), x, bigEndian); |
|
469 return this; |
|
470 #else[rw] |
|
471 throw new ReadOnlyBufferException(); |
|
472 #end[rw] |
|
473 } |
|
474 |
|
475 public $Type$Buffer putFloat(int i, float x) { |
|
476 #if[rw] |
|
477 Bits.putFloat(this, ix(checkIndex(i, 4)), x, bigEndian); |
|
478 return this; |
|
479 #else[rw] |
|
480 throw new ReadOnlyBufferException(); |
|
481 #end[rw] |
|
482 } |
|
483 |
|
484 public FloatBuffer asFloatBuffer() { |
|
485 int size = this.remaining() >> 2; |
|
486 int off = offset + position(); |
|
487 return (bigEndian |
|
488 ? (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$B(this, |
|
489 -1, |
|
490 0, |
|
491 size, |
|
492 size, |
|
493 off)) |
|
494 : (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$L(this, |
|
495 -1, |
|
496 0, |
|
497 size, |
|
498 size, |
|
499 off))); |
|
500 } |
|
501 |
|
502 |
|
503 // double |
|
504 |
|
505 #if[rw] |
|
506 |
|
507 public double getDouble() { |
|
508 return Bits.getDouble(this, ix(nextGetIndex(8)), bigEndian); |
|
509 } |
|
510 |
|
511 public double getDouble(int i) { |
|
512 return Bits.getDouble(this, ix(checkIndex(i, 8)), bigEndian); |
|
513 } |
|
514 |
|
515 #end[rw] |
|
516 |
|
517 public $Type$Buffer putDouble(double x) { |
|
518 #if[rw] |
|
519 Bits.putDouble(this, ix(nextPutIndex(8)), x, bigEndian); |
|
520 return this; |
|
521 #else[rw] |
|
522 throw new ReadOnlyBufferException(); |
|
523 #end[rw] |
|
524 } |
|
525 |
|
526 public $Type$Buffer putDouble(int i, double x) { |
|
527 #if[rw] |
|
528 Bits.putDouble(this, ix(checkIndex(i, 8)), x, bigEndian); |
|
529 return this; |
|
530 #else[rw] |
|
531 throw new ReadOnlyBufferException(); |
|
532 #end[rw] |
|
533 } |
|
534 |
|
535 public DoubleBuffer asDoubleBuffer() { |
|
536 int size = this.remaining() >> 3; |
|
537 int off = offset + position(); |
|
538 return (bigEndian |
|
539 ? (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$B(this, |
|
540 -1, |
|
541 0, |
|
542 size, |
|
543 size, |
|
544 off)) |
|
545 : (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$L(this, |
|
546 -1, |
|
547 0, |
|
548 size, |
|
549 size, |
|
550 off))); |
|
551 } |
|
552 |
|
553 |
|
554 #end[byte] |
|
555 |
|
556 |
|
557 #if[char] |
|
558 |
|
559 String toString(int start, int end) { // package-private |
|
560 try { |
|
561 return new String(hb, start + offset, end - start); |
|
562 } catch (StringIndexOutOfBoundsException x) { |
|
563 throw new IndexOutOfBoundsException(); |
|
564 } |
|
565 } |
|
566 |
|
567 |
|
568 // --- Methods to support CharSequence --- |
|
569 |
|
570 public CharBuffer subSequence(int start, int end) { |
|
571 if ((start < 0) |
|
572 || (end > length()) |
|
573 || (start > end)) |
|
574 throw new IndexOutOfBoundsException(); |
|
575 int pos = position(); |
|
576 return new HeapCharBuffer$RW$(hb, |
|
577 -1, |
|
578 pos + start, |
|
579 pos + end, |
|
580 capacity(), |
|
581 offset); |
|
582 } |
|
583 |
|
584 #end[char] |
|
585 |
|
586 |
|
587 #if[!byte] |
|
588 |
|
589 public ByteOrder order() { |
|
590 return ByteOrder.nativeOrder(); |
|
591 } |
|
592 |
|
593 #end[!byte] |
|
594 |
|
595 } |
|