History

Added some missing classes from java/nio, fixed some bad things

Dmitry Kabak (userdima committed 13 years ago

Commit 7d47bc81 parent b1be22084 files · +40111 −23Browse files

Showing the changes to java/pkg/java/nio/DirectCharBufferU.java (1 of 84 files). Show all

Unified · Split

java/pkg/java/nio/DirectCharBufferU.java+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// -- This file was mechanically generated: Do not edit! -- //
27
28package java.nio;
29
30import java.io.FileDescriptor;
31import sun.misc.Cleaner;
32import sun.misc.Unsafe;
33import sun.misc.VM;
34import sun.nio.ch.DirectBuffer;
35
36
37class DirectCharBufferU
38
39 extends CharBuffer
40
41
42
43 implements DirectBuffer
44{
45
46
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(char[].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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106 public Cleaner cleaner() { return null; }
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174 // For duplicates and slices
175 //
176 DirectCharBufferU(DirectBuffer db, // package-private
177 int mark, int pos, int lim, int cap,
178 int off)
179 {
180
181 super(mark, pos, lim, cap);
182 address = db.address() + off;
183 viewedBuffer = db;
184
185
186
187
188
189
190 }
191
192 public CharBuffer 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 << 1);
198 assert (off >= 0);
199 return new DirectCharBufferU(this, -1, 0, rem, rem, off);
200 }
201
202 public CharBuffer duplicate() {
203 return new DirectCharBufferU(this,
204 this.markValue(),
205 this.position(),
206 this.limit(),
207 this.capacity(),
208 0);
209 }
210
211 public CharBuffer asReadOnlyBuffer() {
212
213 return new DirectCharBufferRU(this,
214 this.markValue(),
215 this.position(),
216 this.limit(),
217 this.capacity(),
218 0);
219
220
221
222 }
223
224
225
226 public long address() {
227 return address;
228 }
229
230 private long ix(int i) {
231 return address + (i << 1);
232 }
233
234 public char get() {
235 return ((unsafe.getChar(ix(nextGetIndex()))));
236 }
237
238 public char get(int i) {
239 return ((unsafe.getChar(ix(checkIndex(i)))));
240 }
241
242 public CharBuffer get(char[] dst, int offset, int length) {
243
244 if ((length << 1) > 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
254 if (order() != ByteOrder.nativeOrder())
255 Bits.copyToCharArray(ix(pos), dst,
256 offset << 1,
257 length << 1);
258 else
259
260 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261 offset << 1,
262 length << 1);
263 position(pos + length);
264 } else {
265 super.get(dst, offset, length);
266 }
267 return this;
268
269
270
271 }
272
273
274
275 public CharBuffer put(char x) {
276
277 unsafe.putChar(ix(nextPutIndex()), ((x)));
278 return this;
279
280
281
282 }
283
284 public CharBuffer put(int i, char x) {
285
286 unsafe.putChar(ix(checkIndex(i)), ((x)));
287 return this;
288
289
290
291 }
292
293 public CharBuffer put(CharBuffer src) {
294
295 if (src instanceof DirectCharBufferU) {
296 if (src == this)
297 throw new IllegalArgumentException();
298 DirectCharBufferU sb = (DirectCharBufferU)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 << 1);
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
330
331
332 }
333
334 public CharBuffer put(char[] src, int offset, int length) {
335
336 if ((length << 1) > 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
346 if (order() != ByteOrder.nativeOrder())
347 Bits.copyFromCharArray(src, offset << 1,
348 ix(pos), length << 1);
349 else
350
351 Bits.copyFromArray(src, arrayBaseOffset, offset << 1,
352 ix(pos), length << 1);
353 position(pos + length);
354 } else {
355 super.put(src, offset, length);
356 }
357 return this;
358
359
360
361 }
362
363 public CharBuffer compact() {
364
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 << 1);
371 position(rem);
372 limit(capacity());
373 discardMark();
374 return this;
375
376
377
378 }
379
380 public boolean isDirect() {
381 return true;
382 }
383
384 public boolean isReadOnly() {
385 return false;
386 }
387
388
389
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 DirectCharBufferU(this,
421 -1,
422 pos + start,
423 pos + end,
424 capacity(),
425 offset);
426 }
427
428
429
430
431
432
433
434 public ByteOrder order() {
435
436
437
438
439
440 return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
441 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
442
443 }
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470}