1 /*
2 * Copyright (c) 2000, 2008, 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
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 }