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 (84 of 84 files). Show all

Unified · Split

84 files
  1. java/pkg/java/nio/Bits.java +18 −14
  2. java/pkg/java/nio/Bits_L.b +65 −0
  3. java/pkg/java/nio/Bits_L.m +18 −0
  4. java/pkg/java/nio/BufferOverflowException.java +51 −0
  5. java/pkg/java/nio/BufferUnderflowException.java +51 −0
  6. java/pkg/java/nio/ByteBuffer.java +2046 −0
  7. java/pkg/java/nio/ByteBufferAsCharBufferB.java +219 −0
  8. java/pkg/java/nio/ByteBufferAsCharBufferL.java +219 −0
  9. java/pkg/java/nio/ByteBufferAsCharBufferRB.java +219 −0
  10. java/pkg/java/nio/ByteBufferAsCharBufferRL.java +219 −0
  11. java/pkg/java/nio/ByteBufferAsDoubleBufferB.java +219 −0
  12. java/pkg/java/nio/ByteBufferAsDoubleBufferL.java +219 −0
  13. java/pkg/java/nio/ByteBufferAsDoubleBufferRB.java +219 −0
  14. java/pkg/java/nio/ByteBufferAsDoubleBufferRL.java +219 −0
  15. java/pkg/java/nio/ByteBufferAsFloatBufferB.java +219 −0
  16. java/pkg/java/nio/ByteBufferAsFloatBufferL.java +219 −0
  17. java/pkg/java/nio/ByteBufferAsFloatBufferRB.java +219 −0
  18. java/pkg/java/nio/ByteBufferAsFloatBufferRL.java +219 −0
  19. java/pkg/java/nio/ByteBufferAsIntBufferB.java +219 −0
  20. java/pkg/java/nio/ByteBufferAsIntBufferL.java +219 −0
  21. java/pkg/java/nio/ByteBufferAsIntBufferRB.java +219 −0
  22. java/pkg/java/nio/ByteBufferAsIntBufferRL.java +219 −0
  23. java/pkg/java/nio/ByteBufferAsLongBufferB.java +219 −0
  24. java/pkg/java/nio/ByteBufferAsLongBufferL.java +219 −0
  25. java/pkg/java/nio/ByteBufferAsLongBufferRB.java +219 −0
  26. java/pkg/java/nio/ByteBufferAsLongBufferRL.java +219 −0
  27. java/pkg/java/nio/ByteBufferAsShortBufferB.java +219 −0
  28. java/pkg/java/nio/ByteBufferAsShortBufferL.java +219 −0
  29. java/pkg/java/nio/ByteBufferAsShortBufferRB.java +219 −0
  30. java/pkg/java/nio/ByteBufferAsShortBufferRL.java +219 −0
  31. java/pkg/java/nio/CharBuffer.java +1463 −0
  32. java/pkg/java/nio/DirectByteBuffer.java +1009 −0
  33. java/pkg/java/nio/DirectByteBufferR.java +1009 −0
  34. java/pkg/java/nio/DirectCharBufferRS.java +470 −0
  35. java/pkg/java/nio/DirectCharBufferRU.java +470 −0
  36. java/pkg/java/nio/DirectCharBufferS.java +470 −0
  37. java/pkg/java/nio/DirectCharBufferU.java +470 −0
  38. java/pkg/java/nio/DirectDoubleBufferRS.java +470 −0
  39. java/pkg/java/nio/DirectDoubleBufferRU.java +470 −0
  40. java/pkg/java/nio/DirectDoubleBufferS.java +470 −0
  41. java/pkg/java/nio/DirectDoubleBufferU.java +470 −0
  42. java/pkg/java/nio/DirectFloatBufferRS.java +470 −0
  43. java/pkg/java/nio/DirectFloatBufferRU.java +470 −0
  44. java/pkg/java/nio/DirectFloatBufferS.java +470 −0
  45. java/pkg/java/nio/DirectFloatBufferU.java +470 −0
  46. java/pkg/java/nio/DirectIntBufferRS.java +470 −0
  47. java/pkg/java/nio/DirectIntBufferRU.java +470 −0
  48. java/pkg/java/nio/DirectIntBufferS.java +470 −0
  49. java/pkg/java/nio/DirectIntBufferU.java +470 −0
  50. java/pkg/java/nio/DirectLongBufferRS.java +470 −0
  51. java/pkg/java/nio/DirectLongBufferRU.java +470 −0
  52. java/pkg/java/nio/DirectLongBufferS.java +470 −0
  53. java/pkg/java/nio/DirectLongBufferU.java +470 −0
  54. java/pkg/java/nio/DirectShortBufferRS.java +470 −0
  55. java/pkg/java/nio/DirectShortBufferRU.java +470 −0
  56. java/pkg/java/nio/DirectShortBufferS.java +470 −0
  57. java/pkg/java/nio/DirectShortBufferU.java +470 −0
  58. java/pkg/java/nio/DoubleBuffer.java +1451 −0
  59. java/pkg/java/nio/FloatBuffer.java +1451 −0
  60. java/pkg/java/nio/HeapByteBuffer.java +602 −0
  61. java/pkg/java/nio/HeapByteBufferR.java +595 −0
  62. java/pkg/java/nio/HeapCharBuffer.java +602 −0
  63. java/pkg/java/nio/HeapCharBufferR.java +595 −0
  64. java/pkg/java/nio/HeapDoubleBuffer.java +595 −0
  65. java/pkg/java/nio/HeapDoubleBufferR.java +595 −0
  66. java/pkg/java/nio/HeapFloatBuffer.java +595 −0
  67. java/pkg/java/nio/HeapFloatBufferR.java +595 −0
  68. java/pkg/java/nio/HeapIntBuffer.java +595 −0
  69. java/pkg/java/nio/HeapIntBufferR.java +595 −0
  70. java/pkg/java/nio/HeapLongBuffer.java +595 −0
  71. java/pkg/java/nio/HeapLongBufferR.java +595 −0
  72. java/pkg/java/nio/HeapShortBuffer.java +595 −0
  73. java/pkg/java/nio/HeapShortBufferR.java +595 −0
  74. java/pkg/java/nio/IntBuffer.java +1451 −0
  75. java/pkg/java/nio/InvalidMarkException.java +51 −0
  76. java/pkg/java/nio/LongBuffer.java +1451 −0
  77. java/pkg/java/nio/ReadOnlyBufferException.java +51 −0
  78. java/pkg/java/nio/ShortBuffer.java +1451 −0
  79. java/pkg/java/nio/charset/CharacterCodingException.java +51 −0
  80. java/pkg/java/nio/charset/Charset.java +13 −9
  81. java/pkg/java/nio/charset/CharsetDecoder.java +972 −0
  82. java/pkg/java/nio/charset/CharsetEncoder.java +972 −0
  83. java/pkg/java/nio/charset/IllegalCharsetNameException.java +68 −0
  84. java/pkg/java/nio/charset/UnsupportedCharsetException.java +68 −0
java/pkg/java/nio/Bits.java+18−14
@@ -571,20 +571,24 @@ class Bits { // package-private · 570 unmodified lines
571571 }
572572
573573 static {
574− long a = unsafe.allocateMemory(8);
575− try {
576− unsafe.putLong(a, 0x0102030405060708L);
577− byte b = unsafe.getByte(a);
578− switch (b) {
579− case 0x01: byteOrder = ByteOrder.BIG_ENDIAN; break;
580− case 0x08: byteOrder = ByteOrder.LITTLE_ENDIAN; break;
581− default:
582− assert false;
583− byteOrder = null;
584− }
585− } finally {
586− unsafe.freeMemory(a);
587− }
574+ // [Inferno] <
575+ //long a = unsafe.allocateMemory(8);
576+ //try {
577+ // unsafe.putLong(a, 0x0102030405060708L);
578+ // byte b = unsafe.getByte(a);
579+ // switch (b) {
580+ // case 0x01: byteOrder = ByteOrder.BIG_ENDIAN; break;
581+ // case 0x08: byteOrder = ByteOrder.LITTLE_ENDIAN; break;
582+ // default:
583+ // assert false;
584+ // byteOrder = null;
585+ // }
586+ //} finally {
587+ // unsafe.freeMemory(a);
588+ //}
589+ // [Inferno] =
590+ byteOrder = ByteOrder.LITTLE_ENDIAN;
591+ // [Inferno] >
588592 }
589593
590594
java/pkg/java/nio/Bits_L.b+65−0
@@ -0,0 +1,65 @@
1+implement Bits_L;
2+
3+include "jni.m";
4+ jni : JNI;
5+ ClassModule,
6+ JString,
7+ JArray,
8+ JArrayI,
9+ JArrayC,
10+ JArrayB,
11+ JArrayS,
12+ JArrayJ,
13+ JArrayF,
14+ JArrayD,
15+ JArrayZ,
16+ JArrayJObject,
17+ JArrayJClass,
18+ JArrayJString,
19+ JClass,
20+ JObject : import jni;
21+
22+#>> extra pre includes here
23+
24+#<<
25+
26+include "Bits_L.m";
27+
28+#>> extra post includes here
29+
30+#<<
31+
32+init( jni_p : JNI )
33+{
34+ # save java native inteface mod instance
35+ jni = jni_p;
36+ #>>extra initialization here
37+ #<<
38+}
39+
40+# TODO: implement this
41+
42+copyFromShortArray_rObject_J_J_J_V( p0 : JObject,p1 : big,p2 : big,p3 : big)
43+{#>>
44+}#<<
45+
46+copyToShortArray_J_rObject_J_J_V( p0 : big,p1 : JObject,p2 : big,p3 : big)
47+{#>>
48+}#<<
49+
50+copyFromIntArray_rObject_J_J_J_V( p0 : JObject,p1 : big,p2 : big,p3 : big)
51+{#>>
52+}#<<
53+
54+copyToIntArray_J_rObject_J_J_V( p0 : big,p1 : JObject,p2 : big,p3 : big)
55+{#>>
56+}#<<
57+
58+copyFromLongArray_rObject_J_J_J_V( p0 : JObject,p1 : big,p2 : big,p3 : big)
59+{#>>
60+}#<<
61+
62+copyToLongArray_J_rObject_J_J_V( p0 : big,p1 : JObject,p2 : big,p3 : big)
63+{#>>
64+}#<<
65+
java/pkg/java/nio/Bits_L.m+18−0
@@ -0,0 +1,18 @@
1+# generated file edit with care
2+
3+Bits_L : module
4+{
5+ Bits_obj : adt
6+ {
7+ cl_mod : ClassModule;
8+ };
9+
10+ init : fn( jni_p : JNI );
11+ copyFromShortArray_rObject_J_J_J_V : fn( p0 : JObject,p1 : big,p2 : big,p3 : big);
12+ copyToShortArray_J_rObject_J_J_V : fn( p0 : big,p1 : JObject,p2 : big,p3 : big);
13+ copyFromIntArray_rObject_J_J_J_V : fn( p0 : JObject,p1 : big,p2 : big,p3 : big);
14+ copyToIntArray_J_rObject_J_J_V : fn( p0 : big,p1 : JObject,p2 : big,p3 : big);
15+ copyFromLongArray_rObject_J_J_J_V : fn( p0 : JObject,p1 : big,p2 : big,p3 : big);
16+ copyToLongArray_J_rObject_J_J_V : fn( p0 : big,p1 : JObject,p2 : big,p3 : big);
17+
18+};
java/pkg/java/nio/BufferOverflowException.java+51−0
@@ -0,0 +1,51 @@
1+/*
2+ * Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
3+ *
4+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5+ *
6+ * This code is free software; you can redistribute it and/or modify it
7+ * under the terms of the GNU General Public License version 2 only, as
8+ * published by the Free Software Foundation. Oracle designates this
9+ * particular file as subject to the "Classpath" exception as provided
10+ * by Oracle in the LICENSE file that accompanied this code.
11+ *
12+ * This code is distributed in the hope that it will be useful, but WITHOUT
13+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15+ * version 2 for more details (a copy is included in the LICENSE file that
16+ * accompanied this code).
17+ *
18+ * You should have received a copy of the GNU General Public License version
19+ * 2 along with this work; if not, write to the Free Software Foundation,
20+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21+ *
22+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23+ * or visit www.oracle.com if you need additional information or have any
24+ * questions.
25+ *
26+ */
27+
28+// -- This file was mechanically generated: Do not edit! -- //
29+
30+package java.nio;
31+
32+
33+/**
34+ * Unchecked exception thrown when a relative <i>put</i> operation reaches
35+ * the target buffer's limit.
36+ *
37+ * @since 1.4
38+ */
39+
40+public class BufferOverflowException
41+ extends RuntimeException
42+{
43+
44+ private static final long serialVersionUID = -5484897634319144535L;
45+
46+ /**
47+ * Constructs an instance of this class.
48+ */
49+ public BufferOverflowException() { }
50+
51+}
java/pkg/java/nio/BufferUnderflowException.java+51−0
@@ -0,0 +1,51 @@
1+/*
2+ * Copyright (c) 2000, 2007, Oracle and/or its affiliates. All rights reserved.
3+ *
4+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5+ *
6+ * This code is free software; you can redistribute it and/or modify it
7+ * under the terms of the GNU General Public License version 2 only, as
8+ * published by the Free Software Foundation. Oracle designates this
9+ * particular file as subject to the "Classpath" exception as provided
10+ * by Oracle in the LICENSE file that accompanied this code.
11+ *
12+ * This code is distributed in the hope that it will be useful, but WITHOUT
13+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15+ * version 2 for more details (a copy is included in the LICENSE file that
16+ * accompanied this code).
17+ *
18+ * You should have received a copy of the GNU General Public License version
19+ * 2 along with this work; if not, write to the Free Software Foundation,
20+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21+ *
22+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23+ * or visit www.oracle.com if you need additional information or have any
24+ * questions.
25+ *
26+ */
27+
28+// -- This file was mechanically generated: Do not edit! -- //
29+
30+package java.nio;
31+
32+
33+/**
34+ * Unchecked exception thrown when a relative <i>get</i> operation reaches
35+ * the source buffer's limit.
36+ *
37+ * @since 1.4
38+ */
39+
40+public class BufferUnderflowException
41+ extends RuntimeException
42+{
43+
44+ private static final long serialVersionUID = -1713313658691622206L;
45+
46+ /**
47+ * Constructs an instance of this class.
48+ */
49+ public BufferUnderflowException() { }
50+
51+}
java/pkg/java/nio/ByteBuffer.java+2046−0
@@ -0,0 +1,2046 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+
32+
33+
34+/**
35+ * A byte buffer.
36+ *
37+ * <p> This class defines six categories of operations upon
38+ * byte buffers:
39+ *
40+ * <ul>
41+ *
42+ * <li><p> Absolute and relative {@link #get() </code><i>get</i><code>} and
43+ * {@link #put(byte) </code><i>put</i><code>} methods that read and write
44+ * single bytes; </p></li>
45+ *
46+ * <li><p> Relative {@link #get(byte[]) </code><i>bulk get</i><code>}
47+ * methods that transfer contiguous sequences of bytes from this buffer
48+ * into an array; </p></li>
49+ *
50+ * <li><p> Relative {@link #put(byte[]) </code><i>bulk put</i><code>}
51+ * methods that transfer contiguous sequences of bytes from a
52+ * byte array or some other byte
53+ * buffer into this buffer; </p></li>
54+ *
55+
56+ *
57+ * <li><p> Absolute and relative {@link #getChar() </code><i>get</i><code>}
58+ * and {@link #putChar(char) </code><i>put</i><code>} methods that read and
59+ * write values of other primitive types, translating them to and from
60+ * sequences of bytes in a particular byte order; </p></li>
61+ *
62+ * <li><p> Methods for creating <i><a href="#views">view buffers</a></i>,
63+ * which allow a byte buffer to be viewed as a buffer containing values of
64+ * some other primitive type; and </p></li>
65+ *
66+
67+ *
68+ * <li><p> Methods for {@link #compact </code>compacting<code>}, {@link
69+ * #duplicate </code>duplicating<code>}, and {@link #slice
70+ * </code>slicing<code>} a byte buffer. </p></li>
71+ *
72+ * </ul>
73+ *
74+ * <p> Byte buffers can be created either by {@link #allocate
75+ * </code><i>allocation</i><code>}, which allocates space for the buffer's
76+ *
77+
78+ *
79+ * content, or by {@link #wrap(byte[]) </code><i>wrapping</i><code>} an
80+ * existing byte array into a buffer.
81+ *
82+
83+
84+
85+
86+
87+
88+
89+ *
90+
91+ *
92+ * <a name="direct">
93+ * <h4> Direct <i>vs.</i> non-direct buffers </h4>
94+ *
95+ * <p> A byte buffer is either <i>direct</i> or <i>non-direct</i>. Given a
96+ * direct byte buffer, the Java virtual machine will make a best effort to
97+ * perform native I/O operations directly upon it. That is, it will attempt to
98+ * avoid copying the buffer's content to (or from) an intermediate buffer
99+ * before (or after) each invocation of one of the underlying operating
100+ * system's native I/O operations.
101+ *
102+ * <p> A direct byte buffer may be created by invoking the {@link
103+ * #allocateDirect(int) allocateDirect} factory method of this class. The
104+ * buffers returned by this method typically have somewhat higher allocation
105+ * and deallocation costs than non-direct buffers. The contents of direct
106+ * buffers may reside outside of the normal garbage-collected heap, and so
107+ * their impact upon the memory footprint of an application might not be
108+ * obvious. It is therefore recommended that direct buffers be allocated
109+ * primarily for large, long-lived buffers that are subject to the underlying
110+ * system's native I/O operations. In general it is best to allocate direct
111+ * buffers only when they yield a measureable gain in program performance.
112+ *
113+ * <p> A direct byte buffer may also be created by {@link
114+ * java.nio.channels.FileChannel#map </code>mapping<code>} a region of a file
115+ * directly into memory. An implementation of the Java platform may optionally
116+ * support the creation of direct byte buffers from native code via JNI. If an
117+ * instance of one of these kinds of buffers refers to an inaccessible region
118+ * of memory then an attempt to access that region will not change the buffer's
119+ * content and will cause an unspecified exception to be thrown either at the
120+ * time of the access or at some later time.
121+ *
122+ * <p> Whether a byte buffer is direct or non-direct may be determined by
123+ * invoking its {@link #isDirect isDirect} method. This method is provided so
124+ * that explicit buffer management can be done in performance-critical code.
125+ *
126+ *
127+ * <a name="bin">
128+ * <h4> Access to binary data </h4>
129+ *
130+ * <p> This class defines methods for reading and writing values of all other
131+ * primitive types, except <tt>boolean</tt>. Primitive values are translated
132+ * to (or from) sequences of bytes according to the buffer's current byte
133+ * order, which may be retrieved and modified via the {@link #order order}
134+ * methods. Specific byte orders are represented by instances of the {@link
135+ * ByteOrder} class. The initial order of a byte buffer is always {@link
136+ * ByteOrder#BIG_ENDIAN BIG_ENDIAN}.
137+ *
138+ * <p> For access to heterogeneous binary data, that is, sequences of values of
139+ * different types, this class defines a family of absolute and relative
140+ * <i>get</i> and <i>put</i> methods for each type. For 32-bit floating-point
141+ * values, for example, this class defines:
142+ *
143+ * <blockquote><pre>
144+ * float {@link #getFloat()}
145+ * float {@link #getFloat(int) getFloat(int index)}
146+ * void {@link #putFloat(float) putFloat(float f)}
147+ * void {@link #putFloat(int,float) putFloat(int index, float f)}</pre></blockquote>
148+ *
149+ * <p> Corresponding methods are defined for the types <tt>char</tt>,
150+ * <tt>short</tt>, <tt>int</tt>, <tt>long</tt>, and <tt>double</tt>. The index
151+ * parameters of the absolute <i>get</i> and <i>put</i> methods are in terms of
152+ * bytes rather than of the type being read or written.
153+ *
154+ * <a name="views">
155+ *
156+ * <p> For access to homogeneous binary data, that is, sequences of values of
157+ * the same type, this class defines methods that can create <i>views</i> of a
158+ * given byte buffer. A <i>view buffer</i> is simply another buffer whose
159+ * content is backed by the byte buffer. Changes to the byte buffer's content
160+ * will be visible in the view buffer, and vice versa; the two buffers'
161+ * position, limit, and mark values are independent. The {@link
162+ * #asFloatBuffer() asFloatBuffer} method, for example, creates an instance of
163+ * the {@link FloatBuffer} class that is backed by the byte buffer upon which
164+ * the method is invoked. Corresponding view-creation methods are defined for
165+ * the types <tt>char</tt>, <tt>short</tt>, <tt>int</tt>, <tt>long</tt>, and
166+ * <tt>double</tt>.
167+ *
168+ * <p> View buffers have three important advantages over the families of
169+ * type-specific <i>get</i> and <i>put</i> methods described above:
170+ *
171+ * <ul>
172+ *
173+ * <li><p> A view buffer is indexed not in terms of bytes but rather in terms
174+ * of the type-specific size of its values; </p></li>
175+ *
176+ * <li><p> A view buffer provides relative bulk <i>get</i> and <i>put</i>
177+ * methods that can transfer contiguous sequences of values between a buffer
178+ * and an array or some other buffer of the same type; and </p></li>
179+ *
180+ * <li><p> A view buffer is potentially much more efficient because it will
181+ * be direct if, and only if, its backing byte buffer is direct. </p></li>
182+ *
183+ * </ul>
184+ *
185+ * <p> The byte order of a view buffer is fixed to be that of its byte buffer
186+ * at the time that the view is created. </p>
187+ *
188+
189+*
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+*
202+
203+
204+
205+
206+
207+
208+
209+
210+ *
211+
212+ * <h4> Invocation chaining </h4>
213+
214+ *
215+ * <p> Methods in this class that do not otherwise have a value to return are
216+ * specified to return the buffer upon which they are invoked. This allows
217+ * method invocations to be chained.
218+ *
219+
220+ *
221+ * The sequence of statements
222+ *
223+ * <blockquote><pre>
224+ * bb.putInt(0xCAFEBABE);
225+ * bb.putShort(3);
226+ * bb.putShort(45);</pre></blockquote>
227+ *
228+ * can, for example, be replaced by the single statement
229+ *
230+ * <blockquote><pre>
231+ * bb.putInt(0xCAFEBABE).putShort(3).putShort(45);</pre></blockquote>
232+ *
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+ *
251+ *
252+ * @author Mark Reinhold
253+ * @author JSR-51 Expert Group
254+ * @since 1.4
255+ */
256+
257+public abstract class ByteBuffer
258+ extends Buffer
259+ implements Comparable<ByteBuffer>
260+{
261+
262+ // These fields are declared here rather than in Heap-X-Buffer in order to
263+ // reduce the number of virtual method invocations needed to access these
264+ // values, which is especially costly when coding small buffers.
265+ //
266+ final byte[] hb; // Non-null only for heap buffers
267+ final int offset;
268+ boolean isReadOnly; // Valid only for heap buffers
269+
270+ // Creates a new buffer with the given mark, position, limit, capacity,
271+ // backing array, and array offset
272+ //
273+ ByteBuffer(int mark, int pos, int lim, int cap, // package-private
274+ byte[] hb, int offset)
275+ {
276+ super(mark, pos, lim, cap);
277+ this.hb = hb;
278+ this.offset = offset;
279+ }
280+
281+ // Creates a new buffer with the given mark, position, limit, and capacity
282+ //
283+ ByteBuffer(int mark, int pos, int lim, int cap) { // package-private
284+ this(mark, pos, lim, cap, null, 0);
285+ }
286+
287+
288+
289+ /**
290+ * Allocates a new direct byte buffer.
291+ *
292+ * <p> The new buffer's position will be zero, its limit will be its
293+ * capacity, its mark will be undefined, and each of its elements will be
294+ * initialized to zero. Whether or not it has a
295+ * {@link #hasArray </code>backing array<code>} is unspecified.
296+ *
297+ * @param capacity
298+ * The new buffer's capacity, in bytes
299+ *
300+ * @return The new byte buffer
301+ *
302+ * @throws IllegalArgumentException
303+ * If the <tt>capacity</tt> is a negative integer
304+ */
305+ public static ByteBuffer allocateDirect(int capacity) {
306+ return new DirectByteBuffer(capacity);
307+ }
308+
309+
310+
311+ /**
312+ * Allocates a new byte buffer.
313+ *
314+ * <p> The new buffer's position will be zero, its limit will be its
315+ * capacity, its mark will be undefined, and each of its elements will be
316+ * initialized to zero. It will have a {@link #array
317+ * </code>backing array<code>}, and its {@link #arrayOffset </code>array
318+ * offset<code>} will be zero.
319+ *
320+ * @param capacity
321+ * The new buffer's capacity, in bytes
322+ *
323+ * @return The new byte buffer
324+ *
325+ * @throws IllegalArgumentException
326+ * If the <tt>capacity</tt> is a negative integer
327+ */
328+ public static ByteBuffer allocate(int capacity) {
329+ if (capacity < 0)
330+ throw new IllegalArgumentException();
331+ return new HeapByteBuffer(capacity, capacity);
332+ }
333+
334+ /**
335+ * Wraps a byte array into a buffer.
336+ *
337+ * <p> The new buffer will be backed by the given byte array;
338+ * that is, modifications to the buffer will cause the array to be modified
339+ * and vice versa. The new buffer's capacity will be
340+ * <tt>array.length</tt>, its position will be <tt>offset</tt>, its limit
341+ * will be <tt>offset + length</tt>, and its mark will be undefined. Its
342+ * {@link #array </code>backing array<code>} will be the given array, and
343+ * its {@link #arrayOffset </code>array offset<code>} will be zero. </p>
344+ *
345+ * @param array
346+ * The array that will back the new buffer
347+ *
348+ * @param offset
349+ * The offset of the subarray to be used; must be non-negative and
350+ * no larger than <tt>array.length</tt>. The new buffer's position
351+ * will be set to this value.
352+ *
353+ * @param length
354+ * The length of the subarray to be used;
355+ * must be non-negative and no larger than
356+ * <tt>array.length - offset</tt>.
357+ * The new buffer's limit will be set to <tt>offset + length</tt>.
358+ *
359+ * @return The new byte buffer
360+ *
361+ * @throws IndexOutOfBoundsException
362+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
363+ * parameters do not hold
364+ */
365+ public static ByteBuffer wrap(byte[] array,
366+ int offset, int length)
367+ {
368+ try {
369+ return new HeapByteBuffer(array, offset, length);
370+ } catch (IllegalArgumentException x) {
371+ throw new IndexOutOfBoundsException();
372+ }
373+ }
374+
375+ /**
376+ * Wraps a byte array into a buffer.
377+ *
378+ * <p> The new buffer will be backed by the given byte array;
379+ * that is, modifications to the buffer will cause the array to be modified
380+ * and vice versa. The new buffer's capacity and limit will be
381+ * <tt>array.length</tt>, its position will be zero, and its mark will be
382+ * undefined. Its {@link #array </code>backing array<code>} will be the
383+ * given array, and its {@link #arrayOffset </code>array offset<code>} will
384+ * be zero. </p>
385+ *
386+ * @param array
387+ * The array that will back this buffer
388+ *
389+ * @return The new byte buffer
390+ */
391+ public static ByteBuffer wrap(byte[] array) {
392+ return wrap(array, 0, array.length);
393+ }
394+
395+
396+
397+
398+
399+
400+
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+
435+
436+
437+
438+
439+
440+
441+
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+
471+
472+
473+
474+
475+
476+
477+
478+
479+
480+
481+
482+
483+
484+
485+
486+
487+
488+ /**
489+ * Creates a new byte buffer whose content is a shared subsequence of
490+ * this buffer's content.
491+ *
492+ * <p> The content of the new buffer will start at this buffer's current
493+ * position. Changes to this buffer's content will be visible in the new
494+ * buffer, and vice versa; the two buffers' position, limit, and mark
495+ * values will be independent.
496+ *
497+ * <p> The new buffer's position will be zero, its capacity and its limit
498+ * will be the number of bytes remaining in this buffer, and its mark
499+ * will be undefined. The new buffer will be direct if, and only if, this
500+ * buffer is direct, and it will be read-only if, and only if, this buffer
501+ * is read-only. </p>
502+ *
503+ * @return The new byte buffer
504+ */
505+ public abstract ByteBuffer slice();
506+
507+ /**
508+ * Creates a new byte buffer that shares this buffer's content.
509+ *
510+ * <p> The content of the new buffer will be that of this buffer. Changes
511+ * to this buffer's content will be visible in the new buffer, and vice
512+ * versa; the two buffers' position, limit, and mark values will be
513+ * independent.
514+ *
515+ * <p> The new buffer's capacity, limit, position, and mark values will be
516+ * identical to those of this buffer. The new buffer will be direct if,
517+ * and only if, this buffer is direct, and it will be read-only if, and
518+ * only if, this buffer is read-only. </p>
519+ *
520+ * @return The new byte buffer
521+ */
522+ public abstract ByteBuffer duplicate();
523+
524+ /**
525+ * Creates a new, read-only byte buffer that shares this buffer's
526+ * content.
527+ *
528+ * <p> The content of the new buffer will be that of this buffer. Changes
529+ * to this buffer's content will be visible in the new buffer; the new
530+ * buffer itself, however, will be read-only and will not allow the shared
531+ * content to be modified. The two buffers' position, limit, and mark
532+ * values will be independent.
533+ *
534+ * <p> The new buffer's capacity, limit, position, and mark values will be
535+ * identical to those of this buffer.
536+ *
537+ * <p> If this buffer is itself read-only then this method behaves in
538+ * exactly the same way as the {@link #duplicate duplicate} method. </p>
539+ *
540+ * @return The new, read-only byte buffer
541+ */
542+ public abstract ByteBuffer asReadOnlyBuffer();
543+
544+
545+ // -- Singleton get/put methods --
546+
547+ /**
548+ * Relative <i>get</i> method. Reads the byte at this buffer's
549+ * current position, and then increments the position. </p>
550+ *
551+ * @return The byte at the buffer's current position
552+ *
553+ * @throws BufferUnderflowException
554+ * If the buffer's current position is not smaller than its limit
555+ */
556+ public abstract byte get();
557+
558+ /**
559+ * Relative <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
560+ *
561+ * <p> Writes the given byte into this buffer at the current
562+ * position, and then increments the position. </p>
563+ *
564+ * @param b
565+ * The byte to be written
566+ *
567+ * @return This buffer
568+ *
569+ * @throws BufferOverflowException
570+ * If this buffer's current position is not smaller than its limit
571+ *
572+ * @throws ReadOnlyBufferException
573+ * If this buffer is read-only
574+ */
575+ public abstract ByteBuffer put(byte b);
576+
577+ /**
578+ * Absolute <i>get</i> method. Reads the byte at the given
579+ * index. </p>
580+ *
581+ * @param index
582+ * The index from which the byte will be read
583+ *
584+ * @return The byte at the given index
585+ *
586+ * @throws IndexOutOfBoundsException
587+ * If <tt>index</tt> is negative
588+ * or not smaller than the buffer's limit
589+ */
590+ public abstract byte get(int index);
591+
592+ /**
593+ * Absolute <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
594+ *
595+ * <p> Writes the given byte into this buffer at the given
596+ * index. </p>
597+ *
598+ * @param index
599+ * The index at which the byte will be written
600+ *
601+ * @param b
602+ * The byte value to be written
603+ *
604+ * @return This buffer
605+ *
606+ * @throws IndexOutOfBoundsException
607+ * If <tt>index</tt> is negative
608+ * or not smaller than the buffer's limit
609+ *
610+ * @throws ReadOnlyBufferException
611+ * If this buffer is read-only
612+ */
613+ public abstract ByteBuffer put(int index, byte b);
614+
615+
616+ // -- Bulk get operations --
617+
618+ /**
619+ * Relative bulk <i>get</i> method.
620+ *
621+ * <p> This method transfers bytes from this buffer into the given
622+ * destination array. If there are fewer bytes remaining in the
623+ * buffer than are required to satisfy the request, that is, if
624+ * <tt>length</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>, then no
625+ * bytes are transferred and a {@link BufferUnderflowException} is
626+ * thrown.
627+ *
628+ * <p> Otherwise, this method copies <tt>length</tt> bytes from this
629+ * buffer into the given array, starting at the current position of this
630+ * buffer and at the given offset in the array. The position of this
631+ * buffer is then incremented by <tt>length</tt>.
632+ *
633+ * <p> In other words, an invocation of this method of the form
634+ * <tt>src.get(dst,&nbsp;off,&nbsp;len)</tt> has exactly the same effect as
635+ * the loop
636+ *
637+ * <pre>
638+ * for (int i = off; i < off + len; i++)
639+ * dst[i] = src.get(); </pre>
640+ *
641+ * except that it first checks that there are sufficient bytes in
642+ * this buffer and it is potentially much more efficient. </p>
643+ *
644+ * @param dst
645+ * The array into which bytes are to be written
646+ *
647+ * @param offset
648+ * The offset within the array of the first byte to be
649+ * written; must be non-negative and no larger than
650+ * <tt>dst.length</tt>
651+ *
652+ * @param length
653+ * The maximum number of bytes to be written to the given
654+ * array; must be non-negative and no larger than
655+ * <tt>dst.length - offset</tt>
656+ *
657+ * @return This buffer
658+ *
659+ * @throws BufferUnderflowException
660+ * If there are fewer than <tt>length</tt> bytes
661+ * remaining in this buffer
662+ *
663+ * @throws IndexOutOfBoundsException
664+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
665+ * parameters do not hold
666+ */
667+ public ByteBuffer get(byte[] dst, int offset, int length) {
668+ // [Inferno] <
669+ //checkBounds(offset, length, dst.length);
670+ // [Inferno] =
671+ Buffer.checkBounds(offset, length, dst.length);
672+ // [Inferno] >
673+ if (length > remaining())
674+ throw new BufferUnderflowException();
675+ int end = offset + length;
676+ for (int i = offset; i < end; i++)
677+ dst[i] = get();
678+ return this;
679+ }
680+
681+ /**
682+ * Relative bulk <i>get</i> method.
683+ *
684+ * <p> This method transfers bytes from this buffer into the given
685+ * destination array. An invocation of this method of the form
686+ * <tt>src.get(a)</tt> behaves in exactly the same way as the invocation
687+ *
688+ * <pre>
689+ * src.get(a, 0, a.length) </pre>
690+ *
691+ * @return This buffer
692+ *
693+ * @throws BufferUnderflowException
694+ * If there are fewer than <tt>length</tt> bytes
695+ * remaining in this buffer
696+ */
697+ public ByteBuffer get(byte[] dst) {
698+ return get(dst, 0, dst.length);
699+ }
700+
701+
702+ // -- Bulk put operations --
703+
704+ /**
705+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
706+ *
707+ * <p> This method transfers the bytes remaining in the given source
708+ * buffer into this buffer. If there are more bytes remaining in the
709+ * source buffer than in this buffer, that is, if
710+ * <tt>src.remaining()</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>,
711+ * then no bytes are transferred and a {@link
712+ * BufferOverflowException} is thrown.
713+ *
714+ * <p> Otherwise, this method copies
715+ * <i>n</i>&nbsp;=&nbsp;<tt>src.remaining()</tt> bytes from the given
716+ * buffer into this buffer, starting at each buffer's current position.
717+ * The positions of both buffers are then incremented by <i>n</i>.
718+ *
719+ * <p> In other words, an invocation of this method of the form
720+ * <tt>dst.put(src)</tt> has exactly the same effect as the loop
721+ *
722+ * <pre>
723+ * while (src.hasRemaining())
724+ * dst.put(src.get()); </pre>
725+ *
726+ * except that it first checks that there is sufficient space in this
727+ * buffer and it is potentially much more efficient. </p>
728+ *
729+ * @param src
730+ * The source buffer from which bytes are to be read;
731+ * must not be this buffer
732+ *
733+ * @return This buffer
734+ *
735+ * @throws BufferOverflowException
736+ * If there is insufficient space in this buffer
737+ * for the remaining bytes in the source buffer
738+ *
739+ * @throws IllegalArgumentException
740+ * If the source buffer is this buffer
741+ *
742+ * @throws ReadOnlyBufferException
743+ * If this buffer is read-only
744+ */
745+ public ByteBuffer put(ByteBuffer src) {
746+ if (src == this)
747+ throw new IllegalArgumentException();
748+ int n = src.remaining();
749+ if (n > remaining())
750+ throw new BufferOverflowException();
751+ for (int i = 0; i < n; i++)
752+ put(src.get());
753+ return this;
754+ }
755+
756+ /**
757+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
758+ *
759+ * <p> This method transfers bytes into this buffer from the given
760+ * source array. If there are more bytes to be copied from the array
761+ * than remain in this buffer, that is, if
762+ * <tt>length</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>, then no
763+ * bytes are transferred and a {@link BufferOverflowException} is
764+ * thrown.
765+ *
766+ * <p> Otherwise, this method copies <tt>length</tt> bytes from the
767+ * given array into this buffer, starting at the given offset in the array
768+ * and at the current position of this buffer. The position of this buffer
769+ * is then incremented by <tt>length</tt>.
770+ *
771+ * <p> In other words, an invocation of this method of the form
772+ * <tt>dst.put(src,&nbsp;off,&nbsp;len)</tt> has exactly the same effect as
773+ * the loop
774+ *
775+ * <pre>
776+ * for (int i = off; i < off + len; i++)
777+ * dst.put(a[i]); </pre>
778+ *
779+ * except that it first checks that there is sufficient space in this
780+ * buffer and it is potentially much more efficient. </p>
781+ *
782+ * @param src
783+ * The array from which bytes are to be read
784+ *
785+ * @param offset
786+ * The offset within the array of the first byte to be read;
787+ * must be non-negative and no larger than <tt>array.length</tt>
788+ *
789+ * @param length
790+ * The number of bytes to be read from the given array;
791+ * must be non-negative and no larger than
792+ * <tt>array.length - offset</tt>
793+ *
794+ * @return This buffer
795+ *
796+ * @throws BufferOverflowException
797+ * If there is insufficient space in this buffer
798+ *
799+ * @throws IndexOutOfBoundsException
800+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
801+ * parameters do not hold
802+ *
803+ * @throws ReadOnlyBufferException
804+ * If this buffer is read-only
805+ */
806+ public ByteBuffer put(byte[] src, int offset, int length) {
807+ // [Inferno] <
808+ //checkBounds(offset, length, src.length);
809+ // [Inferno] =
810+ Buffer.checkBounds(offset, length, src.length);
811+ // [Inferno] >
812+ if (length > remaining())
813+ throw new BufferOverflowException();
814+ int end = offset + length;
815+ for (int i = offset; i < end; i++)
816+ this.put(src[i]);
817+ return this;
818+ }
819+
820+ /**
821+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
822+ *
823+ * <p> This method transfers the entire content of the given source
824+ * byte array into this buffer. An invocation of this method of the
825+ * form <tt>dst.put(a)</tt> behaves in exactly the same way as the
826+ * invocation
827+ *
828+ * <pre>
829+ * dst.put(a, 0, a.length) </pre>
830+ *
831+ * @return This buffer
832+ *
833+ * @throws BufferOverflowException
834+ * If there is insufficient space in this buffer
835+ *
836+ * @throws ReadOnlyBufferException
837+ * If this buffer is read-only
838+ */
839+ public final ByteBuffer put(byte[] src) {
840+ return put(src, 0, src.length);
841+ }
842+
843+
844+
845+
846+
847+
848+
849+
850+
851+
852+
853+
854+
855+
856+
857+
858+
859+
860+
861+
862+
863+
864+
865+
866+
867+
868+
869+
870+
871+
872+
873+
874+
875+
876+
877+
878+
879+
880+
881+
882+
883+
884+
885+
886+
887+
888+
889+
890+
891+
892+
893+
894+
895+
896+
897+
898+
899+
900+
901+
902+
903+
904+
905+
906+
907+
908+
909+
910+
911+
912+
913+
914+
915+
916+
917+
918+
919+
920+
921+
922+
923+
924+
925+
926+
927+
928+
929+ // -- Other stuff --
930+
931+ /**
932+ * Tells whether or not this buffer is backed by an accessible byte
933+ * array.
934+ *
935+ * <p> If this method returns <tt>true</tt> then the {@link #array() array}
936+ * and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
937+ * </p>
938+ *
939+ * @return <tt>true</tt> if, and only if, this buffer
940+ * is backed by an array and is not read-only
941+ */
942+ public final boolean hasArray() {
943+ return (hb != null) && !isReadOnly;
944+ }
945+
946+ /**
947+ * Returns the byte array that backs this
948+ * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
949+ *
950+ * <p> Modifications to this buffer's content will cause the returned
951+ * array's content to be modified, and vice versa.
952+ *
953+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
954+ * method in order to ensure that this buffer has an accessible backing
955+ * array. </p>
956+ *
957+ * @return The array that backs this buffer
958+ *
959+ * @throws ReadOnlyBufferException
960+ * If this buffer is backed by an array but is read-only
961+ *
962+ * @throws UnsupportedOperationException
963+ * If this buffer is not backed by an accessible array
964+ */
965+ public final byte[] array() {
966+ if (hb == null)
967+ throw new UnsupportedOperationException();
968+ if (isReadOnly)
969+ throw new ReadOnlyBufferException();
970+ return hb;
971+ }
972+
973+ /**
974+ * Returns the offset within this buffer's backing array of the first
975+ * element of the buffer&nbsp;&nbsp;<i>(optional operation)</i>.
976+ *
977+ * <p> If this buffer is backed by an array then buffer position <i>p</i>
978+ * corresponds to array index <i>p</i>&nbsp;+&nbsp;<tt>arrayOffset()</tt>.
979+ *
980+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
981+ * method in order to ensure that this buffer has an accessible backing
982+ * array. </p>
983+ *
984+ * @return The offset within this buffer's array
985+ * of the first element of the buffer
986+ *
987+ * @throws ReadOnlyBufferException
988+ * If this buffer is backed by an array but is read-only
989+ *
990+ * @throws UnsupportedOperationException
991+ * If this buffer is not backed by an accessible array
992+ */
993+ public final int arrayOffset() {
994+ if (hb == null)
995+ throw new UnsupportedOperationException();
996+ if (isReadOnly)
997+ throw new ReadOnlyBufferException();
998+ return offset;
999+ }
1000+
1001+ /**
1002+ * Compacts this buffer&nbsp;&nbsp;<i>(optional operation)</i>.
1003+ *
1004+ * <p> The bytes between the buffer's current position and its limit,
1005+ * if any, are copied to the beginning of the buffer. That is, the
1006+ * byte at index <i>p</i>&nbsp;=&nbsp;<tt>position()</tt> is copied
1007+ * to index zero, the byte at index <i>p</i>&nbsp;+&nbsp;1 is copied
1008+ * to index one, and so forth until the byte at index
1009+ * <tt>limit()</tt>&nbsp;-&nbsp;1 is copied to index
1010+ * <i>n</i>&nbsp;=&nbsp;<tt>limit()</tt>&nbsp;-&nbsp;<tt>1</tt>&nbsp;-&nbsp;<i>p</i>.
1011+ * The buffer's position is then set to <i>n+1</i> and its limit is set to
1012+ * its capacity. The mark, if defined, is discarded.
1013+ *
1014+ * <p> The buffer's position is set to the number of bytes copied,
1015+ * rather than to zero, so that an invocation of this method can be
1016+ * followed immediately by an invocation of another relative <i>put</i>
1017+ * method. </p>
1018+ *
1019+
1020+ *
1021+ * <p> Invoke this method after writing data from a buffer in case the
1022+ * write was incomplete. The following loop, for example, copies bytes
1023+ * from one channel to another via the buffer <tt>buf</tt>:
1024+ *
1025+ * <blockquote><pre>
1026+ * buf.clear(); // Prepare buffer for use
1027+ * while (in.read(buf) >= 0 || buf.position != 0) {
1028+ * buf.flip();
1029+ * out.write(buf);
1030+ * buf.compact(); // In case of partial write
1031+ * }</pre></blockquote>
1032+ *
1033+
1034+ *
1035+ * @return This buffer
1036+ *
1037+ * @throws ReadOnlyBufferException
1038+ * If this buffer is read-only
1039+ */
1040+ public abstract ByteBuffer compact();
1041+
1042+ /**
1043+ * Tells whether or not this byte buffer is direct. </p>
1044+ *
1045+ * @return <tt>true</tt> if, and only if, this buffer is direct
1046+ */
1047+ public abstract boolean isDirect();
1048+
1049+
1050+
1051+ /**
1052+ * Returns a string summarizing the state of this buffer. </p>
1053+ *
1054+ * @return A summary string
1055+ */
1056+ public String toString() {
1057+ StringBuffer sb = new StringBuffer();
1058+ sb.append(getClass().getName());
1059+ sb.append("[pos=");
1060+ sb.append(position());
1061+ sb.append(" lim=");
1062+ sb.append(limit());
1063+ sb.append(" cap=");
1064+ sb.append(capacity());
1065+ sb.append("]");
1066+ return sb.toString();
1067+ }
1068+
1069+
1070+
1071+
1072+
1073+
1074+ /**
1075+ * Returns the current hash code of this buffer.
1076+ *
1077+ * <p> The hash code of a byte buffer depends only upon its remaining
1078+ * elements; that is, upon the elements from <tt>position()</tt> up to, and
1079+ * including, the element at <tt>limit()</tt>&nbsp;-&nbsp;<tt>1</tt>.
1080+ *
1081+ * <p> Because buffer hash codes are content-dependent, it is inadvisable
1082+ * to use buffers as keys in hash maps or similar data structures unless it
1083+ * is known that their contents will not change. </p>
1084+ *
1085+ * @return The current hash code of this buffer
1086+ */
1087+ public int hashCode() {
1088+ int h = 1;
1089+ int p = position();
1090+ for (int i = limit() - 1; i >= p; i--)
1091+ h = 31 * h + (int)get(i);
1092+ return h;
1093+ }
1094+
1095+ /**
1096+ * Tells whether or not this buffer is equal to another object.
1097+ *
1098+ * <p> Two byte buffers are equal if, and only if,
1099+ *
1100+ * <p><ol>
1101+ *
1102+ * <li><p> They have the same element type, </p></li>
1103+ *
1104+ * <li><p> They have the same number of remaining elements, and
1105+ * </p></li>
1106+ *
1107+ * <li><p> The two sequences of remaining elements, considered
1108+ * independently of their starting positions, are pointwise equal.
1109+
1110+
1111+
1112+
1113+
1114+
1115+
1116+ * </p></li>
1117+ *
1118+ * </ol>
1119+ *
1120+ * <p> A byte buffer is not equal to any other type of object. </p>
1121+ *
1122+ * @param ob The object to which this buffer is to be compared
1123+ *
1124+ * @return <tt>true</tt> if, and only if, this buffer is equal to the
1125+ * given object
1126+ */
1127+ public boolean equals(Object ob) {
1128+ if (this == ob)
1129+ return true;
1130+ if (!(ob instanceof ByteBuffer))
1131+ return false;
1132+ ByteBuffer that = (ByteBuffer)ob;
1133+ if (this.remaining() != that.remaining())
1134+ return false;
1135+ int p = this.position();
1136+ for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)
1137+ if (!equals(this.get(i), that.get(j)))
1138+ return false;
1139+ return true;
1140+ }
1141+
1142+ private static boolean equals(byte x, byte y) {
1143+
1144+
1145+
1146+ return x == y;
1147+
1148+ }
1149+
1150+ /**
1151+ * Compares this buffer to another.
1152+ *
1153+ * <p> Two byte buffers are compared by comparing their sequences of
1154+ * remaining elements lexicographically, without regard to the starting
1155+ * position of each sequence within its corresponding buffer.
1156+
1157+
1158+
1159+
1160+
1161+
1162+
1163+
1164+ * Pairs of {@code byte} elements are compared as if by invoking
1165+ * {@link Byte#compare(byte,byte)}.
1166+
1167+ *
1168+ * <p> A byte buffer is not comparable to any other type of object.
1169+ *
1170+ * @return A negative integer, zero, or a positive integer as this buffer
1171+ * is less than, equal to, or greater than the given buffer
1172+ */
1173+ public int compareTo(ByteBuffer that) {
1174+ int n = this.position() + Math.min(this.remaining(), that.remaining());
1175+ for (int i = this.position(), j = that.position(); i < n; i++, j++) {
1176+ int cmp = compare(this.get(i), that.get(j));
1177+ if (cmp != 0)
1178+ return cmp;
1179+ }
1180+ return this.remaining() - that.remaining();
1181+ }
1182+
1183+ private static int compare(byte x, byte y) {
1184+
1185+
1186+
1187+
1188+
1189+
1190+ return Byte.compare(x, y);
1191+
1192+ }
1193+
1194+ // -- Other char stuff --
1195+
1196+
1197+
1198+
1199+
1200+
1201+
1202+
1203+
1204+
1205+
1206+
1207+
1208+
1209+
1210+
1211+
1212+
1213+
1214+
1215+
1216+
1217+
1218+
1219+
1220+
1221+
1222+
1223+
1224+
1225+
1226+
1227+
1228+
1229+
1230+
1231+
1232+
1233+
1234+
1235+
1236+
1237+
1238+
1239+
1240+
1241+
1242+
1243+
1244+
1245+
1246+
1247+
1248+
1249+
1250+
1251+
1252+
1253+
1254+
1255+
1256+
1257+
1258+
1259+
1260+
1261+
1262+
1263+
1264+
1265+
1266+
1267+
1268+
1269+
1270+
1271+
1272+
1273+
1274+
1275+
1276+
1277+
1278+
1279+
1280+
1281+
1282+
1283+
1284+
1285+
1286+
1287+
1288+
1289+
1290+
1291+
1292+
1293+
1294+
1295+
1296+
1297+
1298+
1299+
1300+
1301+
1302+
1303+
1304+
1305+
1306+
1307+
1308+
1309+
1310+
1311+
1312+
1313+
1314+
1315+
1316+
1317+
1318+
1319+
1320+
1321+
1322+
1323+
1324+
1325+
1326+
1327+
1328+
1329+
1330+
1331+
1332+
1333+
1334+
1335+
1336+
1337+
1338+
1339+
1340+
1341+
1342+
1343+
1344+
1345+
1346+
1347+
1348+
1349+
1350+
1351+
1352+
1353+
1354+
1355+
1356+
1357+
1358+
1359+
1360+
1361+
1362+
1363+
1364+
1365+
1366+
1367+
1368+
1369+
1370+
1371+
1372+
1373+
1374+
1375+
1376+
1377+
1378+
1379+
1380+
1381+
1382+
1383+
1384+
1385+
1386+
1387+
1388+
1389+ // -- Other byte stuff: Access to binary data --
1390+
1391+
1392+
1393+
1394+
1395+
1396+
1397+
1398+
1399+
1400+
1401+
1402+
1403+
1404+
1405+
1406+
1407+
1408+
1409+
1410+
1411+ boolean bigEndian // package-private
1412+ = true;
1413+ boolean nativeByteOrder // package-private
1414+ = (Bits.byteOrder() == ByteOrder.BIG_ENDIAN);
1415+
1416+ /**
1417+ * Retrieves this buffer's byte order.
1418+ *
1419+ * <p> The byte order is used when reading or writing multibyte values, and
1420+ * when creating buffers that are views of this byte buffer. The order of
1421+ * a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN
1422+ * BIG_ENDIAN}. </p>
1423+ *
1424+ * @return This buffer's byte order
1425+ */
1426+ public final ByteOrder order() {
1427+ return bigEndian ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN;
1428+ }
1429+
1430+ /**
1431+ * Modifies this buffer's byte order. </p>
1432+ *
1433+ * @param bo
1434+ * The new byte order,
1435+ * either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}
1436+ * or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN}
1437+ *
1438+ * @return This buffer
1439+ */
1440+ public final ByteBuffer order(ByteOrder bo) {
1441+ bigEndian = (bo == ByteOrder.BIG_ENDIAN);
1442+ nativeByteOrder =
1443+ (bigEndian == (Bits.byteOrder() == ByteOrder.BIG_ENDIAN));
1444+ return this;
1445+ }
1446+
1447+ // Unchecked accessors, for use by ByteBufferAs-X-Buffer classes
1448+ //
1449+ abstract byte _get(int i); // package-private
1450+ abstract void _put(int i, byte b); // package-private
1451+
1452+
1453+ /**
1454+ * Relative <i>get</i> method for reading a char value.
1455+ *
1456+ * <p> Reads the next two bytes at this buffer's current position,
1457+ * composing them into a char value according to the current byte order,
1458+ * and then increments the position by two. </p>
1459+ *
1460+ * @return The char value at the buffer's current position
1461+ *
1462+ * @throws BufferUnderflowException
1463+ * If there are fewer than two bytes
1464+ * remaining in this buffer
1465+ */
1466+ public abstract char getChar();
1467+
1468+ /**
1469+ * Relative <i>put</i> method for writing a char
1470+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1471+ *
1472+ * <p> Writes two bytes containing the given char value, in the
1473+ * current byte order, into this buffer at the current position, and then
1474+ * increments the position by two. </p>
1475+ *
1476+ * @param value
1477+ * The char value to be written
1478+ *
1479+ * @return This buffer
1480+ *
1481+ * @throws BufferOverflowException
1482+ * If there are fewer than two bytes
1483+ * remaining in this buffer
1484+ *
1485+ * @throws ReadOnlyBufferException
1486+ * If this buffer is read-only
1487+ */
1488+ public abstract ByteBuffer putChar(char value);
1489+
1490+ /**
1491+ * Absolute <i>get</i> method for reading a char value.
1492+ *
1493+ * <p> Reads two bytes at the given index, composing them into a
1494+ * char value according to the current byte order. </p>
1495+ *
1496+ * @param index
1497+ * The index from which the bytes will be read
1498+ *
1499+ * @return The char value at the given index
1500+ *
1501+ * @throws IndexOutOfBoundsException
1502+ * If <tt>index</tt> is negative
1503+ * or not smaller than the buffer's limit,
1504+ * minus one
1505+ */
1506+ public abstract char getChar(int index);
1507+
1508+ /**
1509+ * Absolute <i>put</i> method for writing a char
1510+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1511+ *
1512+ * <p> Writes two bytes containing the given char value, in the
1513+ * current byte order, into this buffer at the given index. </p>
1514+ *
1515+ * @param index
1516+ * The index at which the bytes will be written
1517+ *
1518+ * @param value
1519+ * The char value to be written
1520+ *
1521+ * @return This buffer
1522+ *
1523+ * @throws IndexOutOfBoundsException
1524+ * If <tt>index</tt> is negative
1525+ * or not smaller than the buffer's limit,
1526+ * minus one
1527+ *
1528+ * @throws ReadOnlyBufferException
1529+ * If this buffer is read-only
1530+ */
1531+ public abstract ByteBuffer putChar(int index, char value);
1532+
1533+ /**
1534+ * Creates a view of this byte buffer as a char buffer.
1535+ *
1536+ * <p> The content of the new buffer will start at this buffer's current
1537+ * position. Changes to this buffer's content will be visible in the new
1538+ * buffer, and vice versa; the two buffers' position, limit, and mark
1539+ * values will be independent.
1540+ *
1541+ * <p> The new buffer's position will be zero, its capacity and its limit
1542+ * will be the number of bytes remaining in this buffer divided by
1543+ * two, and its mark will be undefined. The new buffer will be direct
1544+ * if, and only if, this buffer is direct, and it will be read-only if, and
1545+ * only if, this buffer is read-only. </p>
1546+ *
1547+ * @return A new char buffer
1548+ */
1549+ public abstract CharBuffer asCharBuffer();
1550+
1551+
1552+ /**
1553+ * Relative <i>get</i> method for reading a short value.
1554+ *
1555+ * <p> Reads the next two bytes at this buffer's current position,
1556+ * composing them into a short value according to the current byte order,
1557+ * and then increments the position by two. </p>
1558+ *
1559+ * @return The short value at the buffer's current position
1560+ *
1561+ * @throws BufferUnderflowException
1562+ * If there are fewer than two bytes
1563+ * remaining in this buffer
1564+ */
1565+ public abstract short getShort();
1566+
1567+ /**
1568+ * Relative <i>put</i> method for writing a short
1569+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1570+ *
1571+ * <p> Writes two bytes containing the given short value, in the
1572+ * current byte order, into this buffer at the current position, and then
1573+ * increments the position by two. </p>
1574+ *
1575+ * @param value
1576+ * The short value to be written
1577+ *
1578+ * @return This buffer
1579+ *
1580+ * @throws BufferOverflowException
1581+ * If there are fewer than two bytes
1582+ * remaining in this buffer
1583+ *
1584+ * @throws ReadOnlyBufferException
1585+ * If this buffer is read-only
1586+ */
1587+ public abstract ByteBuffer putShort(short value);
1588+
1589+ /**
1590+ * Absolute <i>get</i> method for reading a short value.
1591+ *
1592+ * <p> Reads two bytes at the given index, composing them into a
1593+ * short value according to the current byte order. </p>
1594+ *
1595+ * @param index
1596+ * The index from which the bytes will be read
1597+ *
1598+ * @return The short value at the given index
1599+ *
1600+ * @throws IndexOutOfBoundsException
1601+ * If <tt>index</tt> is negative
1602+ * or not smaller than the buffer's limit,
1603+ * minus one
1604+ */
1605+ public abstract short getShort(int index);
1606+
1607+ /**
1608+ * Absolute <i>put</i> method for writing a short
1609+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1610+ *
1611+ * <p> Writes two bytes containing the given short value, in the
1612+ * current byte order, into this buffer at the given index. </p>
1613+ *
1614+ * @param index
1615+ * The index at which the bytes will be written
1616+ *
1617+ * @param value
1618+ * The short value to be written
1619+ *
1620+ * @return This buffer
1621+ *
1622+ * @throws IndexOutOfBoundsException
1623+ * If <tt>index</tt> is negative
1624+ * or not smaller than the buffer's limit,
1625+ * minus one
1626+ *
1627+ * @throws ReadOnlyBufferException
1628+ * If this buffer is read-only
1629+ */
1630+ public abstract ByteBuffer putShort(int index, short value);
1631+
1632+ /**
1633+ * Creates a view of this byte buffer as a short buffer.
1634+ *
1635+ * <p> The content of the new buffer will start at this buffer's current
1636+ * position. Changes to this buffer's content will be visible in the new
1637+ * buffer, and vice versa; the two buffers' position, limit, and mark
1638+ * values will be independent.
1639+ *
1640+ * <p> The new buffer's position will be zero, its capacity and its limit
1641+ * will be the number of bytes remaining in this buffer divided by
1642+ * two, and its mark will be undefined. The new buffer will be direct
1643+ * if, and only if, this buffer is direct, and it will be read-only if, and
1644+ * only if, this buffer is read-only. </p>
1645+ *
1646+ * @return A new short buffer
1647+ */
1648+ public abstract ShortBuffer asShortBuffer();
1649+
1650+
1651+ /**
1652+ * Relative <i>get</i> method for reading an int value.
1653+ *
1654+ * <p> Reads the next four bytes at this buffer's current position,
1655+ * composing them into an int value according to the current byte order,
1656+ * and then increments the position by four. </p>
1657+ *
1658+ * @return The int value at the buffer's current position
1659+ *
1660+ * @throws BufferUnderflowException
1661+ * If there are fewer than four bytes
1662+ * remaining in this buffer
1663+ */
1664+ public abstract int getInt();
1665+
1666+ /**
1667+ * Relative <i>put</i> method for writing an int
1668+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1669+ *
1670+ * <p> Writes four bytes containing the given int value, in the
1671+ * current byte order, into this buffer at the current position, and then
1672+ * increments the position by four. </p>
1673+ *
1674+ * @param value
1675+ * The int value to be written
1676+ *
1677+ * @return This buffer
1678+ *
1679+ * @throws BufferOverflowException
1680+ * If there are fewer than four bytes
1681+ * remaining in this buffer
1682+ *
1683+ * @throws ReadOnlyBufferException
1684+ * If this buffer is read-only
1685+ */
1686+ public abstract ByteBuffer putInt(int value);
1687+
1688+ /**
1689+ * Absolute <i>get</i> method for reading an int value.
1690+ *
1691+ * <p> Reads four bytes at the given index, composing them into a
1692+ * int value according to the current byte order. </p>
1693+ *
1694+ * @param index
1695+ * The index from which the bytes will be read
1696+ *
1697+ * @return The int value at the given index
1698+ *
1699+ * @throws IndexOutOfBoundsException
1700+ * If <tt>index</tt> is negative
1701+ * or not smaller than the buffer's limit,
1702+ * minus three
1703+ */
1704+ public abstract int getInt(int index);
1705+
1706+ /**
1707+ * Absolute <i>put</i> method for writing an int
1708+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1709+ *
1710+ * <p> Writes four bytes containing the given int value, in the
1711+ * current byte order, into this buffer at the given index. </p>
1712+ *
1713+ * @param index
1714+ * The index at which the bytes will be written
1715+ *
1716+ * @param value
1717+ * The int value to be written
1718+ *
1719+ * @return This buffer
1720+ *
1721+ * @throws IndexOutOfBoundsException
1722+ * If <tt>index</tt> is negative
1723+ * or not smaller than the buffer's limit,
1724+ * minus three
1725+ *
1726+ * @throws ReadOnlyBufferException
1727+ * If this buffer is read-only
1728+ */
1729+ public abstract ByteBuffer putInt(int index, int value);
1730+
1731+ /**
1732+ * Creates a view of this byte buffer as an int buffer.
1733+ *
1734+ * <p> The content of the new buffer will start at this buffer's current
1735+ * position. Changes to this buffer's content will be visible in the new
1736+ * buffer, and vice versa; the two buffers' position, limit, and mark
1737+ * values will be independent.
1738+ *
1739+ * <p> The new buffer's position will be zero, its capacity and its limit
1740+ * will be the number of bytes remaining in this buffer divided by
1741+ * four, and its mark will be undefined. The new buffer will be direct
1742+ * if, and only if, this buffer is direct, and it will be read-only if, and
1743+ * only if, this buffer is read-only. </p>
1744+ *
1745+ * @return A new int buffer
1746+ */
1747+ public abstract IntBuffer asIntBuffer();
1748+
1749+
1750+ /**
1751+ * Relative <i>get</i> method for reading a long value.
1752+ *
1753+ * <p> Reads the next eight bytes at this buffer's current position,
1754+ * composing them into a long value according to the current byte order,
1755+ * and then increments the position by eight. </p>
1756+ *
1757+ * @return The long value at the buffer's current position
1758+ *
1759+ * @throws BufferUnderflowException
1760+ * If there are fewer than eight bytes
1761+ * remaining in this buffer
1762+ */
1763+ public abstract long getLong();
1764+
1765+ /**
1766+ * Relative <i>put</i> method for writing a long
1767+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1768+ *
1769+ * <p> Writes eight bytes containing the given long value, in the
1770+ * current byte order, into this buffer at the current position, and then
1771+ * increments the position by eight. </p>
1772+ *
1773+ * @param value
1774+ * The long value to be written
1775+ *
1776+ * @return This buffer
1777+ *
1778+ * @throws BufferOverflowException
1779+ * If there are fewer than eight bytes
1780+ * remaining in this buffer
1781+ *
1782+ * @throws ReadOnlyBufferException
1783+ * If this buffer is read-only
1784+ */
1785+ public abstract ByteBuffer putLong(long value);
1786+
1787+ /**
1788+ * Absolute <i>get</i> method for reading a long value.
1789+ *
1790+ * <p> Reads eight bytes at the given index, composing them into a
1791+ * long value according to the current byte order. </p>
1792+ *
1793+ * @param index
1794+ * The index from which the bytes will be read
1795+ *
1796+ * @return The long value at the given index
1797+ *
1798+ * @throws IndexOutOfBoundsException
1799+ * If <tt>index</tt> is negative
1800+ * or not smaller than the buffer's limit,
1801+ * minus seven
1802+ */
1803+ public abstract long getLong(int index);
1804+
1805+ /**
1806+ * Absolute <i>put</i> method for writing a long
1807+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1808+ *
1809+ * <p> Writes eight bytes containing the given long value, in the
1810+ * current byte order, into this buffer at the given index. </p>
1811+ *
1812+ * @param index
1813+ * The index at which the bytes will be written
1814+ *
1815+ * @param value
1816+ * The long value to be written
1817+ *
1818+ * @return This buffer
1819+ *
1820+ * @throws IndexOutOfBoundsException
1821+ * If <tt>index</tt> is negative
1822+ * or not smaller than the buffer's limit,
1823+ * minus seven
1824+ *
1825+ * @throws ReadOnlyBufferException
1826+ * If this buffer is read-only
1827+ */
1828+ public abstract ByteBuffer putLong(int index, long value);
1829+
1830+ /**
1831+ * Creates a view of this byte buffer as a long buffer.
1832+ *
1833+ * <p> The content of the new buffer will start at this buffer's current
1834+ * position. Changes to this buffer's content will be visible in the new
1835+ * buffer, and vice versa; the two buffers' position, limit, and mark
1836+ * values will be independent.
1837+ *
1838+ * <p> The new buffer's position will be zero, its capacity and its limit
1839+ * will be the number of bytes remaining in this buffer divided by
1840+ * eight, and its mark will be undefined. The new buffer will be direct
1841+ * if, and only if, this buffer is direct, and it will be read-only if, and
1842+ * only if, this buffer is read-only. </p>
1843+ *
1844+ * @return A new long buffer
1845+ */
1846+ public abstract LongBuffer asLongBuffer();
1847+
1848+
1849+ /**
1850+ * Relative <i>get</i> method for reading a float value.
1851+ *
1852+ * <p> Reads the next four bytes at this buffer's current position,
1853+ * composing them into a float value according to the current byte order,
1854+ * and then increments the position by four. </p>
1855+ *
1856+ * @return The float value at the buffer's current position
1857+ *
1858+ * @throws BufferUnderflowException
1859+ * If there are fewer than four bytes
1860+ * remaining in this buffer
1861+ */
1862+ public abstract float getFloat();
1863+
1864+ /**
1865+ * Relative <i>put</i> method for writing a float
1866+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1867+ *
1868+ * <p> Writes four bytes containing the given float value, in the
1869+ * current byte order, into this buffer at the current position, and then
1870+ * increments the position by four. </p>
1871+ *
1872+ * @param value
1873+ * The float value to be written
1874+ *
1875+ * @return This buffer
1876+ *
1877+ * @throws BufferOverflowException
1878+ * If there are fewer than four bytes
1879+ * remaining in this buffer
1880+ *
1881+ * @throws ReadOnlyBufferException
1882+ * If this buffer is read-only
1883+ */
1884+ public abstract ByteBuffer putFloat(float value);
1885+
1886+ /**
1887+ * Absolute <i>get</i> method for reading a float value.
1888+ *
1889+ * <p> Reads four bytes at the given index, composing them into a
1890+ * float value according to the current byte order. </p>
1891+ *
1892+ * @param index
1893+ * The index from which the bytes will be read
1894+ *
1895+ * @return The float value at the given index
1896+ *
1897+ * @throws IndexOutOfBoundsException
1898+ * If <tt>index</tt> is negative
1899+ * or not smaller than the buffer's limit,
1900+ * minus three
1901+ */
1902+ public abstract float getFloat(int index);
1903+
1904+ /**
1905+ * Absolute <i>put</i> method for writing a float
1906+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1907+ *
1908+ * <p> Writes four bytes containing the given float value, in the
1909+ * current byte order, into this buffer at the given index. </p>
1910+ *
1911+ * @param index
1912+ * The index at which the bytes will be written
1913+ *
1914+ * @param value
1915+ * The float value to be written
1916+ *
1917+ * @return This buffer
1918+ *
1919+ * @throws IndexOutOfBoundsException
1920+ * If <tt>index</tt> is negative
1921+ * or not smaller than the buffer's limit,
1922+ * minus three
1923+ *
1924+ * @throws ReadOnlyBufferException
1925+ * If this buffer is read-only
1926+ */
1927+ public abstract ByteBuffer putFloat(int index, float value);
1928+
1929+ /**
1930+ * Creates a view of this byte buffer as a float buffer.
1931+ *
1932+ * <p> The content of the new buffer will start at this buffer's current
1933+ * position. Changes to this buffer's content will be visible in the new
1934+ * buffer, and vice versa; the two buffers' position, limit, and mark
1935+ * values will be independent.
1936+ *
1937+ * <p> The new buffer's position will be zero, its capacity and its limit
1938+ * will be the number of bytes remaining in this buffer divided by
1939+ * four, and its mark will be undefined. The new buffer will be direct
1940+ * if, and only if, this buffer is direct, and it will be read-only if, and
1941+ * only if, this buffer is read-only. </p>
1942+ *
1943+ * @return A new float buffer
1944+ */
1945+ public abstract FloatBuffer asFloatBuffer();
1946+
1947+
1948+ /**
1949+ * Relative <i>get</i> method for reading a double value.
1950+ *
1951+ * <p> Reads the next eight bytes at this buffer's current position,
1952+ * composing them into a double value according to the current byte order,
1953+ * and then increments the position by eight. </p>
1954+ *
1955+ * @return The double value at the buffer's current position
1956+ *
1957+ * @throws BufferUnderflowException
1958+ * If there are fewer than eight bytes
1959+ * remaining in this buffer
1960+ */
1961+ public abstract double getDouble();
1962+
1963+ /**
1964+ * Relative <i>put</i> method for writing a double
1965+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
1966+ *
1967+ * <p> Writes eight bytes containing the given double value, in the
1968+ * current byte order, into this buffer at the current position, and then
1969+ * increments the position by eight. </p>
1970+ *
1971+ * @param value
1972+ * The double value to be written
1973+ *
1974+ * @return This buffer
1975+ *
1976+ * @throws BufferOverflowException
1977+ * If there are fewer than eight bytes
1978+ * remaining in this buffer
1979+ *
1980+ * @throws ReadOnlyBufferException
1981+ * If this buffer is read-only
1982+ */
1983+ public abstract ByteBuffer putDouble(double value);
1984+
1985+ /**
1986+ * Absolute <i>get</i> method for reading a double value.
1987+ *
1988+ * <p> Reads eight bytes at the given index, composing them into a
1989+ * double value according to the current byte order. </p>
1990+ *
1991+ * @param index
1992+ * The index from which the bytes will be read
1993+ *
1994+ * @return The double value at the given index
1995+ *
1996+ * @throws IndexOutOfBoundsException
1997+ * If <tt>index</tt> is negative
1998+ * or not smaller than the buffer's limit,
1999+ * minus seven
2000+ */
2001+ public abstract double getDouble(int index);
2002+
2003+ /**
2004+ * Absolute <i>put</i> method for writing a double
2005+ * value&nbsp;&nbsp;<i>(optional operation)</i>.
2006+ *
2007+ * <p> Writes eight bytes containing the given double value, in the
2008+ * current byte order, into this buffer at the given index. </p>
2009+ *
2010+ * @param index
2011+ * The index at which the bytes will be written
2012+ *
2013+ * @param value
2014+ * The double value to be written
2015+ *
2016+ * @return This buffer
2017+ *
2018+ * @throws IndexOutOfBoundsException
2019+ * If <tt>index</tt> is negative
2020+ * or not smaller than the buffer's limit,
2021+ * minus seven
2022+ *
2023+ * @throws ReadOnlyBufferException
2024+ * If this buffer is read-only
2025+ */
2026+ public abstract ByteBuffer putDouble(int index, double value);
2027+
2028+ /**
2029+ * Creates a view of this byte buffer as a double buffer.
2030+ *
2031+ * <p> The content of the new buffer will start at this buffer's current
2032+ * position. Changes to this buffer's content will be visible in the new
2033+ * buffer, and vice versa; the two buffers' position, limit, and mark
2034+ * values will be independent.
2035+ *
2036+ * <p> The new buffer's position will be zero, its capacity and its limit
2037+ * will be the number of bytes remaining in this buffer divided by
2038+ * eight, and its mark will be undefined. The new buffer will be direct
2039+ * if, and only if, this buffer is direct, and it will be read-only if, and
2040+ * only if, this buffer is read-only. </p>
2041+ *
2042+ * @return A new double buffer
2043+ */
2044+ public abstract DoubleBuffer asDoubleBuffer();
2045+
2046+}
java/pkg/java/nio/ByteBufferAsCharBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsCharBufferB // package-private
32+ extends CharBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsCharBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 1,
46+ bb.remaining() >> 1);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsCharBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public CharBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsCharBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public CharBuffer duplicate() {
83+ return new ByteBufferAsCharBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public CharBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsCharBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 1) + offset;
108+ }
109+
110+ public char get() {
111+ return Bits.getCharB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public char get(int i) {
115+ return Bits.getCharB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public CharBuffer put(char x) {
121+
122+ Bits.putCharB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public CharBuffer put(int i, char x) {
130+
131+ Bits.putCharB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public CharBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 1);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+ public String toString(int start, int end) {
171+ if ((end > limit()) || (start > end))
172+ throw new IndexOutOfBoundsException();
173+ try {
174+ int len = end - start;
175+ char[] ca = new char[len];
176+ CharBuffer cb = CharBuffer.wrap(ca);
177+ CharBuffer db = this.duplicate();
178+ db.position(start);
179+ db.limit(end);
180+ cb.put(db);
181+ return new String(ca);
182+ } catch (StringIndexOutOfBoundsException x) {
183+ throw new IndexOutOfBoundsException();
184+ }
185+ }
186+
187+
188+ // --- Methods to support CharSequence ---
189+
190+ public CharBuffer subSequence(int start, int end) {
191+ int pos = position();
192+ int lim = limit();
193+ assert (pos <= lim);
194+ pos = (pos <= lim ? pos : lim);
195+ int len = lim - pos;
196+
197+ if ((start < 0) || (end > len) || (start > end))
198+ throw new IndexOutOfBoundsException();
199+ return new ByteBufferAsCharBufferB(bb,
200+ -1,
201+ pos + start,
202+ pos + end,
203+ capacity(),
204+ offset);
205+ }
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsCharBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsCharBufferL // package-private
32+ extends CharBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsCharBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 1,
46+ bb.remaining() >> 1);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsCharBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public CharBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsCharBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public CharBuffer duplicate() {
83+ return new ByteBufferAsCharBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public CharBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsCharBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 1) + offset;
108+ }
109+
110+ public char get() {
111+ return Bits.getCharL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public char get(int i) {
115+ return Bits.getCharL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public CharBuffer put(char x) {
121+
122+ Bits.putCharL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public CharBuffer put(int i, char x) {
130+
131+ Bits.putCharL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public CharBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 1);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+ public String toString(int start, int end) {
171+ if ((end > limit()) || (start > end))
172+ throw new IndexOutOfBoundsException();
173+ try {
174+ int len = end - start;
175+ char[] ca = new char[len];
176+ CharBuffer cb = CharBuffer.wrap(ca);
177+ CharBuffer db = this.duplicate();
178+ db.position(start);
179+ db.limit(end);
180+ cb.put(db);
181+ return new String(ca);
182+ } catch (StringIndexOutOfBoundsException x) {
183+ throw new IndexOutOfBoundsException();
184+ }
185+ }
186+
187+
188+ // --- Methods to support CharSequence ---
189+
190+ public CharBuffer subSequence(int start, int end) {
191+ int pos = position();
192+ int lim = limit();
193+ assert (pos <= lim);
194+ pos = (pos <= lim ? pos : lim);
195+ int len = lim - pos;
196+
197+ if ((start < 0) || (end > len) || (start > end))
198+ throw new IndexOutOfBoundsException();
199+ return new ByteBufferAsCharBufferL(bb,
200+ -1,
201+ pos + start,
202+ pos + end,
203+ capacity(),
204+ offset);
205+ }
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsCharBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsCharBufferRB // package-private
32+ extends ByteBufferAsCharBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsCharBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsCharBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public CharBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsCharBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public CharBuffer duplicate() {
83+ return new ByteBufferAsCharBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public CharBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public CharBuffer put(char x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public CharBuffer put(int i, char x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public CharBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+ public String toString(int start, int end) {
171+ if ((end > limit()) || (start > end))
172+ throw new IndexOutOfBoundsException();
173+ try {
174+ int len = end - start;
175+ char[] ca = new char[len];
176+ CharBuffer cb = CharBuffer.wrap(ca);
177+ CharBuffer db = this.duplicate();
178+ db.position(start);
179+ db.limit(end);
180+ cb.put(db);
181+ return new String(ca);
182+ } catch (StringIndexOutOfBoundsException x) {
183+ throw new IndexOutOfBoundsException();
184+ }
185+ }
186+
187+
188+ // --- Methods to support CharSequence ---
189+
190+ public CharBuffer subSequence(int start, int end) {
191+ int pos = position();
192+ int lim = limit();
193+ assert (pos <= lim);
194+ pos = (pos <= lim ? pos : lim);
195+ int len = lim - pos;
196+
197+ if ((start < 0) || (end > len) || (start > end))
198+ throw new IndexOutOfBoundsException();
199+ return new ByteBufferAsCharBufferRB(bb,
200+ -1,
201+ pos + start,
202+ pos + end,
203+ capacity(),
204+ offset);
205+ }
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsCharBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsCharBufferRL // package-private
32+ extends ByteBufferAsCharBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsCharBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsCharBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public CharBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsCharBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public CharBuffer duplicate() {
83+ return new ByteBufferAsCharBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public CharBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public CharBuffer put(char x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public CharBuffer put(int i, char x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public CharBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+ public String toString(int start, int end) {
171+ if ((end > limit()) || (start > end))
172+ throw new IndexOutOfBoundsException();
173+ try {
174+ int len = end - start;
175+ char[] ca = new char[len];
176+ CharBuffer cb = CharBuffer.wrap(ca);
177+ CharBuffer db = this.duplicate();
178+ db.position(start);
179+ db.limit(end);
180+ cb.put(db);
181+ return new String(ca);
182+ } catch (StringIndexOutOfBoundsException x) {
183+ throw new IndexOutOfBoundsException();
184+ }
185+ }
186+
187+
188+ // --- Methods to support CharSequence ---
189+
190+ public CharBuffer subSequence(int start, int end) {
191+ int pos = position();
192+ int lim = limit();
193+ assert (pos <= lim);
194+ pos = (pos <= lim ? pos : lim);
195+ int len = lim - pos;
196+
197+ if ((start < 0) || (end > len) || (start > end))
198+ throw new IndexOutOfBoundsException();
199+ return new ByteBufferAsCharBufferRL(bb,
200+ -1,
201+ pos + start,
202+ pos + end,
203+ capacity(),
204+ offset);
205+ }
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsDoubleBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsDoubleBufferB // package-private
32+ extends DoubleBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsDoubleBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 3,
46+ bb.remaining() >> 3);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsDoubleBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public DoubleBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsDoubleBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public DoubleBuffer duplicate() {
83+ return new ByteBufferAsDoubleBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public DoubleBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsDoubleBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 3) + offset;
108+ }
109+
110+ public double get() {
111+ return Bits.getDoubleB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public double get(int i) {
115+ return Bits.getDoubleB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public DoubleBuffer put(double x) {
121+
122+ Bits.putDoubleB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public DoubleBuffer put(int i, double x) {
130+
131+ Bits.putDoubleB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public DoubleBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 3);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsDoubleBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsDoubleBufferL // package-private
32+ extends DoubleBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsDoubleBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 3,
46+ bb.remaining() >> 3);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsDoubleBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public DoubleBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsDoubleBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public DoubleBuffer duplicate() {
83+ return new ByteBufferAsDoubleBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public DoubleBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsDoubleBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 3) + offset;
108+ }
109+
110+ public double get() {
111+ return Bits.getDoubleL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public double get(int i) {
115+ return Bits.getDoubleL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public DoubleBuffer put(double x) {
121+
122+ Bits.putDoubleL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public DoubleBuffer put(int i, double x) {
130+
131+ Bits.putDoubleL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public DoubleBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 3);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsDoubleBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsDoubleBufferRB // package-private
32+ extends ByteBufferAsDoubleBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsDoubleBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsDoubleBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public DoubleBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsDoubleBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public DoubleBuffer duplicate() {
83+ return new ByteBufferAsDoubleBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public DoubleBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public DoubleBuffer put(double x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public DoubleBuffer put(int i, double x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public DoubleBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsDoubleBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsDoubleBufferRL // package-private
32+ extends ByteBufferAsDoubleBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsDoubleBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsDoubleBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public DoubleBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsDoubleBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public DoubleBuffer duplicate() {
83+ return new ByteBufferAsDoubleBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public DoubleBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public DoubleBuffer put(double x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public DoubleBuffer put(int i, double x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public DoubleBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsFloatBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsFloatBufferB // package-private
32+ extends FloatBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsFloatBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 2,
46+ bb.remaining() >> 2);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsFloatBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public FloatBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsFloatBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public FloatBuffer duplicate() {
83+ return new ByteBufferAsFloatBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public FloatBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsFloatBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 2) + offset;
108+ }
109+
110+ public float get() {
111+ return Bits.getFloatB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public float get(int i) {
115+ return Bits.getFloatB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public FloatBuffer put(float x) {
121+
122+ Bits.putFloatB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public FloatBuffer put(int i, float x) {
130+
131+ Bits.putFloatB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public FloatBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 2);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsFloatBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsFloatBufferL // package-private
32+ extends FloatBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsFloatBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 2,
46+ bb.remaining() >> 2);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsFloatBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public FloatBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsFloatBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public FloatBuffer duplicate() {
83+ return new ByteBufferAsFloatBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public FloatBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsFloatBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 2) + offset;
108+ }
109+
110+ public float get() {
111+ return Bits.getFloatL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public float get(int i) {
115+ return Bits.getFloatL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public FloatBuffer put(float x) {
121+
122+ Bits.putFloatL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public FloatBuffer put(int i, float x) {
130+
131+ Bits.putFloatL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public FloatBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 2);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsFloatBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsFloatBufferRB // package-private
32+ extends ByteBufferAsFloatBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsFloatBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsFloatBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public FloatBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsFloatBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public FloatBuffer duplicate() {
83+ return new ByteBufferAsFloatBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public FloatBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public FloatBuffer put(float x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public FloatBuffer put(int i, float x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public FloatBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsFloatBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsFloatBufferRL // package-private
32+ extends ByteBufferAsFloatBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsFloatBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsFloatBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public FloatBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsFloatBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public FloatBuffer duplicate() {
83+ return new ByteBufferAsFloatBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public FloatBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public FloatBuffer put(float x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public FloatBuffer put(int i, float x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public FloatBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsIntBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsIntBufferB // package-private
32+ extends IntBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsIntBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 2,
46+ bb.remaining() >> 2);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsIntBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public IntBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsIntBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public IntBuffer duplicate() {
83+ return new ByteBufferAsIntBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public IntBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsIntBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 2) + offset;
108+ }
109+
110+ public int get() {
111+ return Bits.getIntB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public int get(int i) {
115+ return Bits.getIntB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public IntBuffer put(int x) {
121+
122+ Bits.putIntB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public IntBuffer put(int i, int x) {
130+
131+ Bits.putIntB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public IntBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 2);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsIntBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsIntBufferL // package-private
32+ extends IntBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsIntBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 2,
46+ bb.remaining() >> 2);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsIntBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public IntBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsIntBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public IntBuffer duplicate() {
83+ return new ByteBufferAsIntBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public IntBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsIntBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 2) + offset;
108+ }
109+
110+ public int get() {
111+ return Bits.getIntL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public int get(int i) {
115+ return Bits.getIntL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public IntBuffer put(int x) {
121+
122+ Bits.putIntL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public IntBuffer put(int i, int x) {
130+
131+ Bits.putIntL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public IntBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 2);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsIntBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsIntBufferRB // package-private
32+ extends ByteBufferAsIntBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsIntBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsIntBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public IntBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsIntBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public IntBuffer duplicate() {
83+ return new ByteBufferAsIntBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public IntBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public IntBuffer put(int x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public IntBuffer put(int i, int x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public IntBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsIntBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsIntBufferRL // package-private
32+ extends ByteBufferAsIntBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsIntBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsIntBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public IntBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 2) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsIntBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public IntBuffer duplicate() {
83+ return new ByteBufferAsIntBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public IntBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public IntBuffer put(int x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public IntBuffer put(int i, int x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public IntBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsLongBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsLongBufferB // package-private
32+ extends LongBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsLongBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 3,
46+ bb.remaining() >> 3);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsLongBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public LongBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsLongBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public LongBuffer duplicate() {
83+ return new ByteBufferAsLongBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public LongBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsLongBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 3) + offset;
108+ }
109+
110+ public long get() {
111+ return Bits.getLongB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public long get(int i) {
115+ return Bits.getLongB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public LongBuffer put(long x) {
121+
122+ Bits.putLongB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public LongBuffer put(int i, long x) {
130+
131+ Bits.putLongB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public LongBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 3);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsLongBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsLongBufferL // package-private
32+ extends LongBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsLongBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 3,
46+ bb.remaining() >> 3);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsLongBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public LongBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsLongBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public LongBuffer duplicate() {
83+ return new ByteBufferAsLongBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public LongBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsLongBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 3) + offset;
108+ }
109+
110+ public long get() {
111+ return Bits.getLongL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public long get(int i) {
115+ return Bits.getLongL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public LongBuffer put(long x) {
121+
122+ Bits.putLongL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public LongBuffer put(int i, long x) {
130+
131+ Bits.putLongL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public LongBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 3);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsLongBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsLongBufferRB // package-private
32+ extends ByteBufferAsLongBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsLongBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsLongBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public LongBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsLongBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public LongBuffer duplicate() {
83+ return new ByteBufferAsLongBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public LongBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public LongBuffer put(long x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public LongBuffer put(int i, long x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public LongBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsLongBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsLongBufferRL // package-private
32+ extends ByteBufferAsLongBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsLongBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsLongBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public LongBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 3) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsLongBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public LongBuffer duplicate() {
83+ return new ByteBufferAsLongBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public LongBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public LongBuffer put(long x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public LongBuffer put(int i, long x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public LongBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsShortBufferB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsShortBufferB // package-private
32+ extends ShortBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsShortBufferB(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 1,
46+ bb.remaining() >> 1);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsShortBufferB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public ShortBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsShortBufferB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public ShortBuffer duplicate() {
83+ return new ByteBufferAsShortBufferB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public ShortBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsShortBufferRB(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 1) + offset;
108+ }
109+
110+ public short get() {
111+ return Bits.getShortB(bb, ix(nextGetIndex()));
112+ }
113+
114+ public short get(int i) {
115+ return Bits.getShortB(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public ShortBuffer put(short x) {
121+
122+ Bits.putShortB(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public ShortBuffer put(int i, short x) {
130+
131+ Bits.putShortB(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public ShortBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 1);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsShortBufferL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsShortBufferL // package-private
32+ extends ShortBuffer
33+{
34+
35+
36+
37+ protected final ByteBuffer bb;
38+ protected final int offset;
39+
40+
41+
42+ ByteBufferAsShortBufferL(ByteBuffer bb) { // package-private
43+
44+ super(-1, 0,
45+ bb.remaining() >> 1,
46+ bb.remaining() >> 1);
47+ this.bb = bb;
48+ // enforce limit == capacity
49+ int cap = this.capacity();
50+ this.limit(cap);
51+ int pos = this.position();
52+ assert (pos <= cap);
53+ offset = pos;
54+
55+
56+
57+ }
58+
59+ ByteBufferAsShortBufferL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+ super(mark, pos, lim, cap);
65+ this.bb = bb;
66+ offset = off;
67+
68+
69+
70+ }
71+
72+ public ShortBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsShortBufferL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public ShortBuffer duplicate() {
83+ return new ByteBufferAsShortBufferL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public ShortBuffer asReadOnlyBuffer() {
92+
93+ return new ByteBufferAsShortBufferRL(bb,
94+ this.markValue(),
95+ this.position(),
96+ this.limit(),
97+ this.capacity(),
98+ offset);
99+
100+
101+
102+ }
103+
104+
105+
106+ protected int ix(int i) {
107+ return (i << 1) + offset;
108+ }
109+
110+ public short get() {
111+ return Bits.getShortL(bb, ix(nextGetIndex()));
112+ }
113+
114+ public short get(int i) {
115+ return Bits.getShortL(bb, ix(checkIndex(i)));
116+ }
117+
118+
119+
120+ public ShortBuffer put(short x) {
121+
122+ Bits.putShortL(bb, ix(nextPutIndex()), x);
123+ return this;
124+
125+
126+
127+ }
128+
129+ public ShortBuffer put(int i, short x) {
130+
131+ Bits.putShortL(bb, ix(checkIndex(i)), x);
132+ return this;
133+
134+
135+
136+ }
137+
138+ public ShortBuffer compact() {
139+
140+ int pos = position();
141+ int lim = limit();
142+ assert (pos <= lim);
143+ int rem = (pos <= lim ? lim - pos : 0);
144+
145+ ByteBuffer db = bb.duplicate();
146+ db.limit(ix(lim));
147+ db.position(ix(0));
148+ ByteBuffer sb = db.slice();
149+ sb.position(pos << 1);
150+ sb.compact();
151+ position(rem);
152+ limit(capacity());
153+ discardMark();
154+ return this;
155+
156+
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return false;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsShortBufferRB.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsShortBufferRB // package-private
32+ extends ByteBufferAsShortBufferB
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsShortBufferRB(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsShortBufferRB(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public ShortBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsShortBufferRB(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public ShortBuffer duplicate() {
83+ return new ByteBufferAsShortBufferRB(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public ShortBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public ShortBuffer put(short x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public ShortBuffer put(int i, short x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public ShortBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+ return ByteOrder.BIG_ENDIAN;
213+
214+
215+
216+
217+ }
218+
219+}
java/pkg/java/nio/ByteBufferAsShortBufferRL.java+219−0
@@ -0,0 +1,219 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+class ByteBufferAsShortBufferRL // package-private
32+ extends ByteBufferAsShortBufferL
33+{
34+
35+
36+
37+
38+
39+
40+
41+
42+ ByteBufferAsShortBufferRL(ByteBuffer bb) { // package-private
43+
44+
45+
46+
47+
48+
49+
50+
51+
52+
53+
54+
55+ super(bb);
56+
57+ }
58+
59+ ByteBufferAsShortBufferRL(ByteBuffer bb,
60+ int mark, int pos, int lim, int cap,
61+ int off)
62+ {
63+
64+
65+
66+
67+
68+ super(bb, mark, pos, lim, cap, off);
69+
70+ }
71+
72+ public ShortBuffer slice() {
73+ int pos = this.position();
74+ int lim = this.limit();
75+ assert (pos <= lim);
76+ int rem = (pos <= lim ? lim - pos : 0);
77+ int off = (pos << 1) + offset;
78+ assert (off >= 0);
79+ return new ByteBufferAsShortBufferRL(bb, -1, 0, rem, rem, off);
80+ }
81+
82+ public ShortBuffer duplicate() {
83+ return new ByteBufferAsShortBufferRL(bb,
84+ this.markValue(),
85+ this.position(),
86+ this.limit(),
87+ this.capacity(),
88+ offset);
89+ }
90+
91+ public ShortBuffer asReadOnlyBuffer() {
92+
93+
94+
95+
96+
97+
98+
99+
100+ return duplicate();
101+
102+ }
103+
104+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+
115+
116+
117+
118+
119+
120+ public ShortBuffer put(short x) {
121+
122+
123+
124+
125+ throw new ReadOnlyBufferException();
126+
127+ }
128+
129+ public ShortBuffer put(int i, short x) {
130+
131+
132+
133+
134+ throw new ReadOnlyBufferException();
135+
136+ }
137+
138+ public ShortBuffer compact() {
139+
140+
141+
142+
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ throw new ReadOnlyBufferException();
157+
158+ }
159+
160+ public boolean isDirect() {
161+ return bb.isDirect();
162+ }
163+
164+ public boolean isReadOnly() {
165+ return true;
166+ }
167+
168+
169+
170+
171+
172+
173+
174+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+
190+
191+
192+
193+
194+
195+
196+
197+
198+
199+
200+
201+
202+
203+
204+
205+
206+
207+
208+
209+
210+ public ByteOrder order() {
211+
212+
213+
214+
215+ return ByteOrder.LITTLE_ENDIAN;
216+
217+ }
218+
219+}
java/pkg/java/nio/CharBuffer.java+1463−0
@@ -0,0 +1,1463 @@
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+// -- This file was mechanically generated: Do not edit! -- //
27+
28+package java.nio;
29+
30+
31+import java.io.IOException;
32+
33+
34+/**
35+ * A char buffer.
36+ *
37+ * <p> This class defines four categories of operations upon
38+ * char buffers:
39+ *
40+ * <ul>
41+ *
42+ * <li><p> Absolute and relative {@link #get() </code><i>get</i><code>} and
43+ * {@link #put(char) </code><i>put</i><code>} methods that read and write
44+ * single chars; </p></li>
45+ *
46+ * <li><p> Relative {@link #get(char[]) </code><i>bulk get</i><code>}
47+ * methods that transfer contiguous sequences of chars from this buffer
48+ * into an array; and</p></li>
49+ *
50+ * <li><p> Relative {@link #put(char[]) </code><i>bulk put</i><code>}
51+ * methods that transfer contiguous sequences of chars from a
52+ * char array,&#32;a&#32;string, or some other char
53+ * buffer into this buffer;&#32;and </p></li>
54+ *
55+
56+
57+
58+
59+
60+
61+
62+
63+
64+
65+
66+
67+ *
68+ * <li><p> Methods for {@link #compact </code>compacting<code>}, {@link
69+ * #duplicate </code>duplicating<code>}, and {@link #slice
70+ * </code>slicing<code>} a char buffer. </p></li>
71+ *
72+ * </ul>
73+ *
74+ * <p> Char buffers can be created either by {@link #allocate
75+ * </code><i>allocation</i><code>}, which allocates space for the buffer's
76+ *
77+
78+
79+
80+
81+
82+
83+ *
84+ * content, by {@link #wrap(char[]) </code><i>wrapping</i><code>} an existing
85+ * char array or&#32;string into a buffer, or by creating a
86+ * <a href="ByteBuffer.html#views"><i>view</i></a> of an existing byte buffer.
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+
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+
175+
176+
177+
178+
179+
180+
181+
182+
183+
184+
185+
186+
187+
188+
189+*
190+
191+ *
192+ * <p> Like a byte buffer, a char buffer is either <a
193+ * href="ByteBuffer.html#direct"><i>direct</i> or <i>non-direct</i></a>. A
194+ * char buffer created via the <tt>wrap</tt> methods of this class will
195+ * be non-direct. A char buffer created as a view of a byte buffer will
196+ * be direct if, and only if, the byte buffer itself is direct. Whether or not
197+ * a char buffer is direct may be determined by invoking the {@link
198+ * #isDirect isDirect} method. </p>
199+ *
200+
201+*
202+
203+ *
204+ * <p> This class implements the {@link CharSequence} interface so that
205+ * character buffers may be used wherever character sequences are accepted, for
206+ * example in the regular-expression package <tt>{@link java.util.regex}</tt>.
207+ * </p>
208+ *
209+
210+ *
211+
212+
213+
214+ *
215+ * <p> Methods in this class that do not otherwise have a value to return are
216+ * specified to return the buffer upon which they are invoked. This allows
217+ * method invocations to be chained.
218+ *
219+
220+
221+
222+
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+ *
236+ * The sequence of statements
237+ *
238+ * <blockquote><pre>
239+ * cb.put("text/");
240+ * cb.put(subtype);
241+ * cb.put("; charset=");
242+ * cb.put(enc);</pre></blockquote>
243+ *
244+ * can, for example, be replaced by the single statement
245+ *
246+ * <blockquote><pre>
247+ * cb.put("text/").put(subtype).put("; charset=").put(enc);</pre></blockquote>
248+ *
249+
250+ *
251+ *
252+ * @author Mark Reinhold
253+ * @author JSR-51 Expert Group
254+ * @since 1.4
255+ */
256+
257+public abstract class CharBuffer
258+ extends Buffer
259+ implements Comparable<CharBuffer>, Appendable, CharSequence, Readable
260+{
261+
262+ // These fields are declared here rather than in Heap-X-Buffer in order to
263+ // reduce the number of virtual method invocations needed to access these
264+ // values, which is especially costly when coding small buffers.
265+ //
266+ final char[] hb; // Non-null only for heap buffers
267+ final int offset;
268+ boolean isReadOnly; // Valid only for heap buffers
269+
270+ // Creates a new buffer with the given mark, position, limit, capacity,
271+ // backing array, and array offset
272+ //
273+ CharBuffer(int mark, int pos, int lim, int cap, // package-private
274+ char[] hb, int offset)
275+ {
276+ super(mark, pos, lim, cap);
277+ this.hb = hb;
278+ this.offset = offset;
279+ }
280+
281+ // Creates a new buffer with the given mark, position, limit, and capacity
282+ //
283+ CharBuffer(int mark, int pos, int lim, int cap) { // package-private
284+ this(mark, pos, lim, cap, null, 0);
285+ }
286+
287+
288+
289+
290+
291+
292+
293+
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+ /**
312+ * Allocates a new char buffer.
313+ *
314+ * <p> The new buffer's position will be zero, its limit will be its
315+ * capacity, its mark will be undefined, and each of its elements will be
316+ * initialized to zero. It will have a {@link #array
317+ * </code>backing array<code>}, and its {@link #arrayOffset </code>array
318+ * offset<code>} will be zero.
319+ *
320+ * @param capacity
321+ * The new buffer's capacity, in chars
322+ *
323+ * @return The new char buffer
324+ *
325+ * @throws IllegalArgumentException
326+ * If the <tt>capacity</tt> is a negative integer
327+ */
328+ public static CharBuffer allocate(int capacity) {
329+ if (capacity < 0)
330+ throw new IllegalArgumentException();
331+ return new HeapCharBuffer(capacity, capacity);
332+ }
333+
334+ /**
335+ * Wraps a char array into a buffer.
336+ *
337+ * <p> The new buffer will be backed by the given char array;
338+ * that is, modifications to the buffer will cause the array to be modified
339+ * and vice versa. The new buffer's capacity will be
340+ * <tt>array.length</tt>, its position will be <tt>offset</tt>, its limit
341+ * will be <tt>offset + length</tt>, and its mark will be undefined. Its
342+ * {@link #array </code>backing array<code>} will be the given array, and
343+ * its {@link #arrayOffset </code>array offset<code>} will be zero. </p>
344+ *
345+ * @param array
346+ * The array that will back the new buffer
347+ *
348+ * @param offset
349+ * The offset of the subarray to be used; must be non-negative and
350+ * no larger than <tt>array.length</tt>. The new buffer's position
351+ * will be set to this value.
352+ *
353+ * @param length
354+ * The length of the subarray to be used;
355+ * must be non-negative and no larger than
356+ * <tt>array.length - offset</tt>.
357+ * The new buffer's limit will be set to <tt>offset + length</tt>.
358+ *
359+ * @return The new char buffer
360+ *
361+ * @throws IndexOutOfBoundsException
362+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
363+ * parameters do not hold
364+ */
365+ public static CharBuffer wrap(char[] array,
366+ int offset, int length)
367+ {
368+ try {
369+ return new HeapCharBuffer(array, offset, length);
370+ } catch (IllegalArgumentException x) {
371+ throw new IndexOutOfBoundsException();
372+ }
373+ }
374+
375+ /**
376+ * Wraps a char array into a buffer.
377+ *
378+ * <p> The new buffer will be backed by the given char array;
379+ * that is, modifications to the buffer will cause the array to be modified
380+ * and vice versa. The new buffer's capacity and limit will be
381+ * <tt>array.length</tt>, its position will be zero, and its mark will be
382+ * undefined. Its {@link #array </code>backing array<code>} will be the
383+ * given array, and its {@link #arrayOffset </code>array offset<code>} will
384+ * be zero. </p>
385+ *
386+ * @param array
387+ * The array that will back this buffer
388+ *
389+ * @return The new char buffer
390+ */
391+ public static CharBuffer wrap(char[] array) {
392+ return wrap(array, 0, array.length);
393+ }
394+
395+
396+
397+ /**
398+ * Attempts to read characters into the specified character buffer.
399+ * The buffer is used as a repository of characters as-is: the only
400+ * changes made are the results of a put operation. No flipping or
401+ * rewinding of the buffer is performed.
402+ *
403+ * @param target the buffer to read characters into
404+ * @return The number of characters added to the buffer, or
405+ * -1 if this source of characters is at its end
406+ * @throws IOException if an I/O error occurs
407+ * @throws NullPointerException if target is null
408+ * @throws ReadOnlyBufferException if target is a read only buffer
409+ * @since 1.5
410+ */
411+ public int read(CharBuffer target) throws IOException {
412+ // Determine the number of bytes n that can be transferred
413+ int targetRemaining = target.remaining();
414+ int remaining = remaining();
415+ if (remaining == 0)
416+ return -1;
417+ int n = Math.min(remaining, targetRemaining);
418+ int limit = limit();
419+ // Set source limit to prevent target overflow
420+ if (targetRemaining < remaining)
421+ limit(position() + n);
422+ try {
423+ if (n > 0)
424+ target.put(this);
425+ } finally {
426+ limit(limit); // restore real limit
427+ }
428+ return n;
429+ }
430+
431+ /**
432+ * Wraps a character sequence into a buffer.
433+ *
434+ * <p> The content of the new, read-only buffer will be the content of the
435+ * given character sequence. The buffer's capacity will be
436+ * <tt>csq.length()</tt>, its position will be <tt>start</tt>, its limit
437+ * will be <tt>end</tt>, and its mark will be undefined. </p>
438+ *
439+ * @param csq
440+ * The character sequence from which the new character buffer is to
441+ * be created
442+ *
443+ * @param start
444+ * The index of the first character to be used;
445+ * must be non-negative and no larger than <tt>csq.length()</tt>.
446+ * The new buffer's position will be set to this value.
447+ *
448+ * @param end
449+ * The index of the character following the last character to be
450+ * used; must be no smaller than <tt>start</tt> and no larger
451+ * than <tt>csq.length()</tt>.
452+ * The new buffer's limit will be set to this value.
453+ *
454+ * @return The new character buffer
455+ *
456+ * @throws IndexOutOfBoundsException
457+ * If the preconditions on the <tt>start</tt> and <tt>end</tt>
458+ * parameters do not hold
459+ */
460+ public static CharBuffer wrap(CharSequence csq, int start, int end) {
461+ try {
462+ return new StringCharBuffer(csq, start, end);
463+ } catch (IllegalArgumentException x) {
464+ throw new IndexOutOfBoundsException();
465+ }
466+ }
467+
468+ /**
469+ * Wraps a character sequence into a buffer.
470+ *
471+ * <p> The content of the new, read-only buffer will be the content of the
472+ * given character sequence. The new buffer's capacity and limit will be
473+ * <tt>csq.length()</tt>, its position will be zero, and its mark will be
474+ * undefined. </p>
475+ *
476+ * @param csq
477+ * The character sequence from which the new character buffer is to
478+ * be created
479+ *
480+ * @return The new character buffer
481+ */
482+ public static CharBuffer wrap(CharSequence csq) {
483+ return wrap(csq, 0, csq.length());
484+ }
485+
486+
487+
488+ /**
489+ * Creates a new char buffer whose content is a shared subsequence of
490+ * this buffer's content.
491+ *
492+ * <p> The content of the new buffer will start at this buffer's current
493+ * position. Changes to this buffer's content will be visible in the new
494+ * buffer, and vice versa; the two buffers' position, limit, and mark
495+ * values will be independent.
496+ *
497+ * <p> The new buffer's position will be zero, its capacity and its limit
498+ * will be the number of chars remaining in this buffer, and its mark
499+ * will be undefined. The new buffer will be direct if, and only if, this
500+ * buffer is direct, and it will be read-only if, and only if, this buffer
501+ * is read-only. </p>
502+ *
503+ * @return The new char buffer
504+ */
505+ public abstract CharBuffer slice();
506+
507+ /**
508+ * Creates a new char buffer that shares this buffer's content.
509+ *
510+ * <p> The content of the new buffer will be that of this buffer. Changes
511+ * to this buffer's content will be visible in the new buffer, and vice
512+ * versa; the two buffers' position, limit, and mark values will be
513+ * independent.
514+ *
515+ * <p> The new buffer's capacity, limit, position, and mark values will be
516+ * identical to those of this buffer. The new buffer will be direct if,
517+ * and only if, this buffer is direct, and it will be read-only if, and
518+ * only if, this buffer is read-only. </p>
519+ *
520+ * @return The new char buffer
521+ */
522+ public abstract CharBuffer duplicate();
523+
524+ /**
525+ * Creates a new, read-only char buffer that shares this buffer's
526+ * content.
527+ *
528+ * <p> The content of the new buffer will be that of this buffer. Changes
529+ * to this buffer's content will be visible in the new buffer; the new
530+ * buffer itself, however, will be read-only and will not allow the shared
531+ * content to be modified. The two buffers' position, limit, and mark
532+ * values will be independent.
533+ *
534+ * <p> The new buffer's capacity, limit, position, and mark values will be
535+ * identical to those of this buffer.
536+ *
537+ * <p> If this buffer is itself read-only then this method behaves in
538+ * exactly the same way as the {@link #duplicate duplicate} method. </p>
539+ *
540+ * @return The new, read-only char buffer
541+ */
542+ public abstract CharBuffer asReadOnlyBuffer();
543+
544+
545+ // -- Singleton get/put methods --
546+
547+ /**
548+ * Relative <i>get</i> method. Reads the char at this buffer's
549+ * current position, and then increments the position. </p>
550+ *
551+ * @return The char at the buffer's current position
552+ *
553+ * @throws BufferUnderflowException
554+ * If the buffer's current position is not smaller than its limit
555+ */
556+ public abstract char get();
557+
558+ /**
559+ * Relative <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
560+ *
561+ * <p> Writes the given char into this buffer at the current
562+ * position, and then increments the position. </p>
563+ *
564+ * @param c
565+ * The char to be written
566+ *
567+ * @return This buffer
568+ *
569+ * @throws BufferOverflowException
570+ * If this buffer's current position is not smaller than its limit
571+ *
572+ * @throws ReadOnlyBufferException
573+ * If this buffer is read-only
574+ */
575+ public abstract CharBuffer put(char c);
576+
577+ /**
578+ * Absolute <i>get</i> method. Reads the char at the given
579+ * index. </p>
580+ *
581+ * @param index
582+ * The index from which the char will be read
583+ *
584+ * @return The char at the given index
585+ *
586+ * @throws IndexOutOfBoundsException
587+ * If <tt>index</tt> is negative
588+ * or not smaller than the buffer's limit
589+ */
590+ public abstract char get(int index);
591+
592+ /**
593+ * Absolute <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
594+ *
595+ * <p> Writes the given char into this buffer at the given
596+ * index. </p>
597+ *
598+ * @param index
599+ * The index at which the char will be written
600+ *
601+ * @param c
602+ * The char value to be written
603+ *
604+ * @return This buffer
605+ *
606+ * @throws IndexOutOfBoundsException
607+ * If <tt>index</tt> is negative
608+ * or not smaller than the buffer's limit
609+ *
610+ * @throws ReadOnlyBufferException
611+ * If this buffer is read-only
612+ */
613+ public abstract CharBuffer put(int index, char c);
614+
615+
616+ // -- Bulk get operations --
617+
618+ /**
619+ * Relative bulk <i>get</i> method.
620+ *
621+ * <p> This method transfers chars from this buffer into the given
622+ * destination array. If there are fewer chars remaining in the
623+ * buffer than are required to satisfy the request, that is, if
624+ * <tt>length</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>, then no
625+ * chars are transferred and a {@link BufferUnderflowException} is
626+ * thrown.
627+ *
628+ * <p> Otherwise, this method copies <tt>length</tt> chars from this
629+ * buffer into the given array, starting at the current position of this
630+ * buffer and at the given offset in the array. The position of this
631+ * buffer is then incremented by <tt>length</tt>.
632+ *
633+ * <p> In other words, an invocation of this method of the form
634+ * <tt>src.get(dst,&nbsp;off,&nbsp;len)</tt> has exactly the same effect as
635+ * the loop
636+ *
637+ * <pre>
638+ * for (int i = off; i < off + len; i++)
639+ * dst[i] = src.get(); </pre>
640+ *
641+ * except that it first checks that there are sufficient chars in
642+ * this buffer and it is potentially much more efficient. </p>
643+ *
644+ * @param dst
645+ * The array into which chars are to be written
646+ *
647+ * @param offset
648+ * The offset within the array of the first char to be
649+ * written; must be non-negative and no larger than
650+ * <tt>dst.length</tt>
651+ *
652+ * @param length
653+ * The maximum number of chars to be written to the given
654+ * array; must be non-negative and no larger than
655+ * <tt>dst.length - offset</tt>
656+ *
657+ * @return This buffer
658+ *
659+ * @throws BufferUnderflowException
660+ * If there are fewer than <tt>length</tt> chars
661+ * remaining in this buffer
662+ *
663+ * @throws IndexOutOfBoundsException
664+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
665+ * parameters do not hold
666+ */
667+ public CharBuffer get(char[] dst, int offset, int length) {
668+ // [Inferno] <
669+ //checkBounds(offset, length, dst.length);
670+ // [Inferno] =
671+ Buffer.checkBounds(offset, length, dst.length);
672+ // [Inferno] >
673+ if (length > remaining())
674+ throw new BufferUnderflowException();
675+ int end = offset + length;
676+ for (int i = offset; i < end; i++)
677+ dst[i] = get();
678+ return this;
679+ }
680+
681+ /**
682+ * Relative bulk <i>get</i> method.
683+ *
684+ * <p> This method transfers chars from this buffer into the given
685+ * destination array. An invocation of this method of the form
686+ * <tt>src.get(a)</tt> behaves in exactly the same way as the invocation
687+ *
688+ * <pre>
689+ * src.get(a, 0, a.length) </pre>
690+ *
691+ * @return This buffer
692+ *
693+ * @throws BufferUnderflowException
694+ * If there are fewer than <tt>length</tt> chars
695+ * remaining in this buffer
696+ */
697+ public CharBuffer get(char[] dst) {
698+ return get(dst, 0, dst.length);
699+ }
700+
701+
702+ // -- Bulk put operations --
703+
704+ /**
705+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
706+ *
707+ * <p> This method transfers the chars remaining in the given source
708+ * buffer into this buffer. If there are more chars remaining in the
709+ * source buffer than in this buffer, that is, if
710+ * <tt>src.remaining()</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>,
711+ * then no chars are transferred and a {@link
712+ * BufferOverflowException} is thrown.
713+ *
714+ * <p> Otherwise, this method copies
715+ * <i>n</i>&nbsp;=&nbsp;<tt>src.remaining()</tt> chars from the given
716+ * buffer into this buffer, starting at each buffer's current position.
717+ * The positions of both buffers are then incremented by <i>n</i>.
718+ *
719+ * <p> In other words, an invocation of this method of the form
720+ * <tt>dst.put(src)</tt> has exactly the same effect as the loop
721+ *
722+ * <pre>
723+ * while (src.hasRemaining())
724+ * dst.put(src.get()); </pre>
725+ *
726+ * except that it first checks that there is sufficient space in this
727+ * buffer and it is potentially much more efficient. </p>
728+ *
729+ * @param src
730+ * The source buffer from which chars are to be read;
731+ * must not be this buffer
732+ *
733+ * @return This buffer
734+ *
735+ * @throws BufferOverflowException
736+ * If there is insufficient space in this buffer
737+ * for the remaining chars in the source buffer
738+ *
739+ * @throws IllegalArgumentException
740+ * If the source buffer is this buffer
741+ *
742+ * @throws ReadOnlyBufferException
743+ * If this buffer is read-only
744+ */
745+ public CharBuffer put(CharBuffer src) {
746+ if (src == this)
747+ throw new IllegalArgumentException();
748+ int n = src.remaining();
749+ if (n > remaining())
750+ throw new BufferOverflowException();
751+ for (int i = 0; i < n; i++)
752+ put(src.get());
753+ return this;
754+ }
755+
756+ /**
757+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
758+ *
759+ * <p> This method transfers chars into this buffer from the given
760+ * source array. If there are more chars to be copied from the array
761+ * than remain in this buffer, that is, if
762+ * <tt>length</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>, then no
763+ * chars are transferred and a {@link BufferOverflowException} is
764+ * thrown.
765+ *
766+ * <p> Otherwise, this method copies <tt>length</tt> chars from the
767+ * given array into this buffer, starting at the given offset in the array
768+ * and at the current position of this buffer. The position of this buffer
769+ * is then incremented by <tt>length</tt>.
770+ *
771+ * <p> In other words, an invocation of this method of the form
772+ * <tt>dst.put(src,&nbsp;off,&nbsp;len)</tt> has exactly the same effect as
773+ * the loop
774+ *
775+ * <pre>
776+ * for (int i = off; i < off + len; i++)
777+ * dst.put(a[i]); </pre>
778+ *
779+ * except that it first checks that there is sufficient space in this
780+ * buffer and it is potentially much more efficient. </p>
781+ *
782+ * @param src
783+ * The array from which chars are to be read
784+ *
785+ * @param offset
786+ * The offset within the array of the first char to be read;
787+ * must be non-negative and no larger than <tt>array.length</tt>
788+ *
789+ * @param length
790+ * The number of chars to be read from the given array;
791+ * must be non-negative and no larger than
792+ * <tt>array.length - offset</tt>
793+ *
794+ * @return This buffer
795+ *
796+ * @throws BufferOverflowException
797+ * If there is insufficient space in this buffer
798+ *
799+ * @throws IndexOutOfBoundsException
800+ * If the preconditions on the <tt>offset</tt> and <tt>length</tt>
801+ * parameters do not hold
802+ *
803+ * @throws ReadOnlyBufferException
804+ * If this buffer is read-only
805+ */
806+ public CharBuffer put(char[] src, int offset, int length) {
807+ // [Inferno] <
808+ //checkBounds(offset, length, src.length);
809+ // [Inferno] =
810+ Buffer.checkBounds(offset, length, src.length);
811+ // [Inferno] >
812+ if (length > remaining())
813+ throw new BufferOverflowException();
814+ int end = offset + length;
815+ for (int i = offset; i < end; i++)
816+ this.put(src[i]);
817+ return this;
818+ }
819+
820+ /**
821+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
822+ *
823+ * <p> This method transfers the entire content of the given source
824+ * char array into this buffer. An invocation of this method of the
825+ * form <tt>dst.put(a)</tt> behaves in exactly the same way as the
826+ * invocation
827+ *
828+ * <pre>
829+ * dst.put(a, 0, a.length) </pre>
830+ *
831+ * @return This buffer
832+ *
833+ * @throws BufferOverflowException
834+ * If there is insufficient space in this buffer
835+ *
836+ * @throws ReadOnlyBufferException
837+ * If this buffer is read-only
838+ */
839+ public final CharBuffer put(char[] src) {
840+ return put(src, 0, src.length);
841+ }
842+
843+
844+
845+ /**
846+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
847+ *
848+ * <p> This method transfers chars from the given string into this
849+ * buffer. If there are more chars to be copied from the string than
850+ * remain in this buffer, that is, if
851+ * <tt>end&nbsp;-&nbsp;start</tt>&nbsp;<tt>&gt;</tt>&nbsp;<tt>remaining()</tt>,
852+ * then no chars are transferred and a {@link
853+ * BufferOverflowException} is thrown.
854+ *
855+ * <p> Otherwise, this method copies
856+ * <i>n</i>&nbsp;=&nbsp;<tt>end</tt>&nbsp;-&nbsp;<tt>start</tt> chars
857+ * from the given string into this buffer, starting at the given
858+ * <tt>start</tt> index and at the current position of this buffer. The
859+ * position of this buffer is then incremented by <i>n</i>.
860+ *
861+ * <p> In other words, an invocation of this method of the form
862+ * <tt>dst.put(src,&nbsp;start,&nbsp;end)</tt> has exactly the same effect
863+ * as the loop
864+ *
865+ * <pre>
866+ * for (int i = start; i < end; i++)
867+ * dst.put(src.charAt(i)); </pre>
868+ *
869+ * except that it first checks that there is sufficient space in this
870+ * buffer and it is potentially much more efficient. </p>
871+ *
872+ * @param src
873+ * The string from which chars are to be read
874+ *
875+ * @param start
876+ * The offset within the string of the first char to be read;
877+ * must be non-negative and no larger than
878+ * <tt>string.length()</tt>
879+ *
880+ * @param end
881+ * The offset within the string of the last char to be read,
882+ * plus one; must be non-negative and no larger than
883+ * <tt>string.length()</tt>
884+ *
885+ * @return This buffer
886+ *
887+ * @throws BufferOverflowException
888+ * If there is insufficient space in this buffer
889+ *
890+ * @throws IndexOutOfBoundsException
891+ * If the preconditions on the <tt>start</tt> and <tt>end</tt>
892+ * parameters do not hold
893+ *
894+ * @throws ReadOnlyBufferException
895+ * If this buffer is read-only
896+ */
897+ public CharBuffer put(String src, int start, int end) {
898+ // [Inferno] <
899+ //checkBounds(start, end - start, src.length());
900+ // [Inferno] =
901+ Buffer.checkBounds(start, end - start, src.length());
902+ // [Inferno] >
903+ for (int i = start; i < end; i++)
904+ this.put(src.charAt(i));
905+ return this;
906+ }
907+
908+ /**
909+ * Relative bulk <i>put</i> method&nbsp;&nbsp;<i>(optional operation)</i>.
910+ *
911+ * <p> This method transfers the entire content of the given source string
912+ * into this buffer. An invocation of this method of the form
913+ * <tt>dst.put(s)</tt> behaves in exactly the same way as the invocation
914+ *
915+ * <pre>
916+ * dst.put(s, 0, s.length()) </pre>
917+ *
918+ * @return This buffer
919+ *
920+ * @throws BufferOverflowException
921+ * If there is insufficient space in this buffer
922+ *
923+ * @throws ReadOnlyBufferException
924+ * If this buffer is read-only
925+ */
926+ public final CharBuffer put(String src) {
927+ return put(src, 0, src.length());
928+ }
929+
930+
931+
932+
933+ // -- Other stuff --
934+
935+ /**
936+ * Tells whether or not this buffer is backed by an accessible char
937+ * array.
938+ *
939+ * <p> If this method returns <tt>true</tt> then the {@link #array() array}
940+ * and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
941+ * </p>
942+ *
943+ * @return <tt>true</tt> if, and only if, this buffer
944+ * is backed by an array and is not read-only
945+ */
946+ public final boolean hasArray() {
947+ return (hb != null) && !isReadOnly;
948+ }
949+
950+ /**
951+ * Returns the char array that backs this
952+ * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
953+ *
954+ * <p> Modifications to this buffer's content will cause the returned
955+ * array's content to be modified, and vice versa.
956+ *
957+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
958+ * method in order to ensure that this buffer has an accessible backing
959+ * array. </p>
960+ *
961+ * @return The array that backs this buffer
962+ *
963+ * @throws ReadOnlyBufferException
964+ * If this buffer is backed by an array but is read-only
965+ *
966+ * @throws UnsupportedOperationException
967+ * If this buffer is not backed by an accessible array
968+ */
969+ public final char[] array() {
970+ if (hb == null)
971+ throw new UnsupportedOperationException();
972+ if (isReadOnly)
973+ throw new ReadOnlyBufferException();
974+ return hb;
975+ }
976+
977+ /**
978+ * Returns the offset within this buffer's backing array of the first
979+ * element of the buffer&nbsp;&nbsp;<i>(optional operation)</i>.
980+ *
981+ * <p> If this buffer is backed by an array then buffer position <i>p</i>
982+ * corresponds to array index <i>p</i>&nbsp;+&nbsp;<tt>arrayOffset()</tt>.
983+ *
984+ * <p> Invoke the {@link #hasArray hasArray} method before invoking this
985+ * method in order to ensure that this buffer has an accessible backing
986+ * array. </p>
987+ *
988+ * @return The offset within this buffer's array
989+ * of the first element of the buffer
990+ *
991+ * @throws ReadOnlyBufferException
992+ * If this buffer is backed by an array but is read-only
993+ *
994+ * @throws UnsupportedOperationException
995+ * If this buffer is not backed by an accessible array
996+ */
997+ public final int arrayOffset() {
998+ if (hb == null)
999+ throw new UnsupportedOperationException();
1000+ if (isReadOnly)
1001+ throw new ReadOnlyBufferException();
1002+ return offset;
1003+ }
1004+
1005+ /**
1006+ * Compacts this buffer&nbsp;&nbsp;<i>(optional operation)</i>.
1007+ *
1008+ * <p> The chars between the buffer's current position and its limit,
1009+ * if any, are copied to the beginning of the buffer. That is, the
1010+ * char at index <i>p</i>&nbsp;=&nbsp;<tt>position()</tt> is copied
1011+ * to index zero, the char at index <i>p</i>&nbsp;+&nbsp;1 is copied
1012+ * to index one, and so forth until the char at index
1013+ * <tt>limit()</tt>&nbsp;-&nbsp;1 is copied to index
1014+ * <i>n</i>&nbsp;=&nbsp;<tt>limit()</tt>&nbsp;-&nbsp;<tt>1</tt>&nbsp;-&nbsp;<i>p</i>.
1015+ * The buffer's position is then set to <i>n+1</i> and its limit is set to
1016+ * its capacity. The mark, if defined, is discarded.
1017+ *
1018+ * <p> The buffer's position is set to the number of chars copied,
1019+ * rather than to zero, so that an invocation of this method can be
1020+ * followed immediately by an invocation of another relative <i>put</i>
1021+ * method. </p>
1022+ *
1023+
1024+
1025+
1026+
1027+
1028+
1029+
1030+
1031+
1032+
1033+
1034+
1035+
1036+
1037+
1038+ *
1039+ * @return This buffer
1040+ *
1041+ * @throws ReadOnlyBufferException
1042+ * If this buffer is read-only
1043+ */
1044+ public abstract CharBuffer compact();
1045+
1046+ /**
1047+ * Tells whether or not this char buffer is direct. </p>
1048+ *
1049+ * @return <tt>true</tt> if, and only if, this buffer is direct
1050+ */
1051+ public abstract boolean isDirect();
1052+
1053+
1054+
1055+
1056+
1057+
1058+
1059+
1060+
1061+
1062+
1063+
1064+
1065+
1066+
1067+
1068+
1069+
1070+
1071+
1072+
1073+
1074+
1075+
1076+
1077+
1078+ /**
1079+ * Returns the current hash code of this buffer.
1080+ *
1081+ * <p> The hash code of a char buffer depends only upon its remaining
1082+ * elements; that is, upon the elements from <tt>position()</tt> up to, and
1083+ * including, the element at <tt>limit()</tt>&nbsp;-&nbsp;<tt>1</tt>.
1084+ *
1085+ * <p> Because buffer hash codes are content-dependent, it is inadvisable
1086+ * to use buffers as keys in hash maps or similar data structures unless it
1087+ * is known that their contents will not change. </p>
1088+ *
1089+ * @return The current hash code of this buffer
1090+ */
1091+ public int hashCode() {
1092+ int h = 1;
1093+ int p = position();
1094+ for (int i = limit() - 1; i >= p; i--)
1095+ h = 31 * h + (int)get(i);
1096+ return h;
1097+ }
1098+
1099+ /**
1100+ * Tells whether or not this buffer is equal to another object.
1101+ *
1102+ * <p> Two char buffers are equal if, and only if,
1103+ *
1104+ * <p><ol>
1105+ *
1106+ * <li><p> They have the same element type, </p></li>
1107+ *
1108+ * <li><p> They have the same number of remaining elements, and
1109+ * </p></li>
1110+ *
1111+ * <li><p> The two sequences of remaining elements, considered
1112+ * independently of their starting positions, are pointwise equal.
1113+
1114+
1115+
1116+
1117+
1118+
1119+
1120+ * </p></li>
1121+ *
1122+ * </ol>
1123+ *
1124+ * <p> A char buffer is not equal to any other type of object. </p>
1125+ *
1126+ * @param ob The object to which this buffer is to be compared
1127+ *
1128+ * @return <tt>true</tt> if, and only if, this buffer is equal to the
1129+ * given object
1130+ */
1131+ public boolean equals(Object ob) {
1132+ if (this == ob)
1133+ return true;
1134+ if (!(ob instanceof CharBuffer))
1135+ return false;
1136+ CharBuffer that = (CharBuffer)ob;
1137+ if (this.remaining() != that.remaining())
1138+ return false;
1139+ int p = this.position();
1140+ for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)
1141+ if (!equals(this.get(i), that.get(j)))
1142+ return false;
1143+ return true;
1144+ }
1145+
1146+ private static boolean equals(char x, char y) {
1147+
1148+
1149+
1150+ return x == y;
1151+
1152+ }
1153+
1154+ /**
1155+ * Compares this buffer to another.
1156+ *
1157+ * <p> Two char buffers are compared by comparing their sequences of
1158+ * remaining elements lexicographically, without regard to the starting
1159+ * position of each sequence within its corresponding buffer.
1160+
1161+
1162+
1163+
1164+
1165+
1166+
1167+
1168+ * Pairs of {@code char} elements are compared as if by invoking
1169+ * {@link Character#compare(char,char)}.
1170+
1171+ *
1172+ * <p> A char buffer is not comparable to any other type of object.
1173+ *
1174+ * @return A negative integer, zero, or a positive integer as this buffer
1175+ * is less than, equal to, or greater than the given buffer
1176+ */
1177+ public int compareTo(CharBuffer that) {
1178+ int n = this.position() + Math.min(this.remaining(), that.remaining());
1179+ for (int i = this.position(), j = that.position(); i < n; i++, j++) {
1180+ int cmp = compare(this.get(i), that.get(j));
1181+ if (cmp != 0)
1182+ return cmp;
1183+ }
1184+ return this.remaining() - that.remaining();
1185+ }
1186+
1187+ private static int compare(char x, char y) {
1188+
1189+
1190+
1191+
1192+
1193+
1194+ return Character.compare(x, y);
1195+
1196+ }
1197+
1198+ // -- Other char stuff --
1199+
1200+
1201+
1202+ /**
1203+ * Returns a string containing the characters in this buffer.
1204+ *
1205+ * <p> The first character of the resulting string will be the character at
1206+ * this buffer's position, while the last character will be the character
1207+ * at index <tt>limit()</tt>&nbsp;-&nbsp;1. Invoking this method does not
1208+ * change the buffer's position. </p>
1209+ *
1210+ * @return The specified string
1211+ */
1212+ public String toString() {
1213+ return toString(position(), limit());
1214+ }
1215+
1216+ abstract String toString(int start, int end); // package-private
1217+
1218+
1219+ // --- Methods to support CharSequence ---
1220+
1221+ /**
1222+ * Returns the length of this character buffer.
1223+ *
1224+ * <p> When viewed as a character sequence, the length of a character
1225+ * buffer is simply the number of characters between the position
1226+ * (inclusive) and the limit (exclusive); that is, it is equivalent to
1227+ * <tt>remaining()</tt>. </p>
1228+ *
1229+ * @return The length of this character buffer
1230+ */
1231+ public final int length() {
1232+ return remaining();
1233+ }
1234+
1235+ /**
1236+ * Reads the character at the given index relative to the current
1237+ * position. </p>
1238+ *
1239+ * @param index
1240+ * The index of the character to be read, relative to the position;
1241+ * must be non-negative and smaller than <tt>remaining()</tt>
1242+ *
1243+ * @return The character at index
1244+ * <tt>position()&nbsp;+&nbsp;index</tt>
1245+ *
1246+ * @throws IndexOutOfBoundsException
1247+ * If the preconditions on <tt>index</tt> do not hold
1248+ */
1249+ public final char charAt(int index) {
1250+ return get(position() + checkIndex(index, 1));
1251+ }
1252+
1253+ /**
1254+ * Creates a new character buffer that represents the specified subsequence
1255+ * of this buffer, relative to the current position.
1256+ *
1257+ * <p> The new buffer will share this buffer's content; that is, if the
1258+ * content of this buffer is mutable then modifications to one buffer will
1259+ * cause the other to be modified. The new buffer's capacity will be that
1260+ * of this buffer, its position will be
1261+ * <tt>position()</tt>&nbsp;+&nbsp;<tt>start</tt>, and its limit will be
1262+ * <tt>position()</tt>&nbsp;+&nbsp;<tt>end</tt>. The new buffer will be
1263+ * direct if, and only if, this buffer is direct, and it will be read-only
1264+ * if, and only if, this buffer is read-only. </p>
1265+ *
1266+ * @param start
1267+ * The index, relative to the current position, of the first
1268+ * character in the subsequence; must be non-negative and no larger
1269+ * than <tt>remaining()</tt>
1270+ *
1271+ * @param end
1272+ * The index, relative to the current position, of the character
1273+ * following the last character in the subsequence; must be no
1274+ * smaller than <tt>start</tt> and no larger than
1275+ * <tt>remaining()</tt>
1276+ *
1277+ * @return The new character buffer
1278+ *
1279+ * @throws IndexOutOfBoundsException
1280+ * If the preconditions on <tt>start</tt> and <tt>end</tt>
1281+ * do not hold
1282+ */
1283+ public abstract CharBuffer subSequence(int start, int end);
1284+
1285+
1286+ // --- Methods to support Appendable ---
1287+
1288+ /**
1289+ * Appends the specified character sequence to this
1290+ * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
1291+ *
1292+ * <p> An invocation of this method of the form <tt>dst.append(csq)</tt>
1293+ * behaves in exactly the same way as the invocation
1294+ *
1295+ * <pre>
1296+ * dst.put(csq.toString()) </pre>
1297+ *
1298+ * <p> Depending on the specification of <tt>toString</tt> for the
1299+ * character sequence <tt>csq</tt>, the entire sequence may not be
1300+ * appended. For instance, invoking the {@link CharBuffer#toString()
1301+ * toString} method of a character buffer will return a subsequence whose
1302+ * content depends upon the buffer's position and limit.
1303+ *
1304+ * @param csq
1305+ * The character sequence to append. If <tt>csq</tt> is
1306+ * <tt>null</tt>, then the four characters <tt>"null"</tt> are
1307+ * appended to this character buffer.
1308+ *
1309+ * @return This buffer
1310+ *
1311+ * @throws BufferOverflowException
1312+ * If there is insufficient space in this buffer
1313+ *
1314+ * @throws ReadOnlyBufferException
1315+ * If this buffer is read-only
1316+ *
1317+ * @since 1.5
1318+ */
1319+ public CharBuffer append(CharSequence csq) {
1320+ if (csq == null)
1321+ return put("null");
1322+ else
1323+ return put(csq.toString());
1324+ }
1325+
1326+ /**
1327+ * Appends a subsequence of the specified character sequence to this
1328+ * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
1329+ *
1330+ * <p> An invocation of this method of the form <tt>dst.append(csq, start,
1331+ * end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in exactly the
1332+ * same way as the invocation
1333+ *
1334+ * <pre>
1335+ * dst.put(csq.subSequence(start, end).toString()) </pre>
1336+ *
1337+ * @param csq
1338+ * The character sequence from which a subsequence will be
1339+ * appended. If <tt>csq</tt> is <tt>null</tt>, then characters
1340+ * will be appended as if <tt>csq</tt> contained the four
1341+ * characters <tt>"null"</tt>.
1342+ *
1343+ * @return This buffer
1344+ *
1345+ * @throws BufferOverflowException
1346+ * If there is insufficient space in this buffer
1347+ *
1348+ * @throws IndexOutOfBoundsException
1349+ * If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
1350+ * is greater than <tt>end</tt>, or <tt>end</tt> is greater than
1351+ * <tt>csq.length()</tt>
1352+ *
1353+ * @throws ReadOnlyBufferException
1354+ * If this buffer is read-only
1355+ *
1356+ * @since 1.5
1357+ */
1358+ public CharBuffer append(CharSequence csq, int start, int end) {
1359+ CharSequence cs = (csq == null ? "null" : csq);
1360+ return put(cs.subSequence(start, end).toString());
1361+ }
1362+
1363+ /**
1364+ * Appends the specified char to this
1365+ * buffer&nbsp;&nbsp;<i>(optional operation)</i>.
1366+ *
1367+ * <p> An invocation of this method of the form <tt>dst.append(c)</tt>
1368+ * behaves in exactly the same way as the invocation
1369+ *
1370+ * <pre>
1371+ * dst.put(c) </pre>
1372+ *
1373+ * @param c
1374+ * The 16-bit char to append
1375+ *
1376+ * @return This buffer
1377+ *
1378+ * @throws BufferOverflowException
1379+ * If there is insufficient space in this buffer
1380+ *
1381+ * @throws ReadOnlyBufferException
1382+ * If this buffer is read-only
1383+ *
1384+ * @since 1.5
1385+ */
1386+ public CharBuffer append(char c) {
1387+ return put(c);
1388+ }
1389+
1390+
1391+
1392+
1393+ // -- Other byte stuff: Access to binary data --
1394+
1395+
1396+
1397+ /**
1398+ * Retrieves this buffer's byte order.
1399+ *
1400+ * <p> The byte order of a char buffer created by allocation or by
1401+ * wrapping an existing <tt>char</tt> array is the {@link
1402+ * ByteOrder#nativeOrder </code>native order<code>} of the underlying
1403+ * hardware. The byte order of a char buffer created as a <a
1404+ * href="ByteBuffer.html#views">view</a> of a byte buffer is that of the
1405+ * byte buffer at the moment that the view is created. </p>
1406+ *
1407+ * @return This buffer's byte order
1408+ */
1409+ public abstract ByteOrder order();
1410+
1411+
1412+
1413+
1414+
1415+
1416+
1417+
1418+
1419+
1420+
1421+
1422+
1423+
1424+
1425+
1426+
1427+
1428+
1429+
1430+
1431+
1432+
1433+
1434+
1435+
1436+
1437+
1438+
1439+
1440+
1441+
1442+
1443+
1444+
1445+
1446+
1447+
1448+
1449+
1450+
1451+
1452+
1453+
1454+
1455+
1456+
1457+
1458+
1459+
1460+
1461+
1462+
1463+}
java/pkg/java/nio/DirectByteBuffer.java+1009−0
@@ -0,0 +1,1009 @@
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+
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 DirectByteBuffer
38+
39+ extends MappedByteBuffer
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(byte[].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+ 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+
105+
106+
107+
108+
109+
110+
111+
112+
113+
114+ // Primary constructor
115+ //
116+ DirectByteBuffer(int cap) { // package-private
117+
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+
140+
141+
142+ }
143+
144+
145+
146+ // Invoked only by JNI: NewDirectByteBuffer(void*, long)
147+ //
148+ private DirectByteBuffer(long addr, int cap) {
149+ super(-1, 0, cap, cap);
150+ address = addr;
151+ cleaner = null;
152+ }
153+
154+
155+
156+ // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
157+ //
158+ protected DirectByteBuffer(int cap, long addr,
159+ FileDescriptor fd,
160+ Runnable unmapper)
161+ {
162+
163+ super(-1, 0, cap, cap, fd);
164+ address = addr;
165+ viewedBuffer = null;
166+ cleaner = Cleaner.create(this, unmapper);
167+
168+
169+
170+ }
171+
172+
173+
174+ // For duplicates and slices
175+ //
176+ DirectByteBuffer(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+ cleaner = null;
186+
187+
188+
189+
190+ }
191+
192+ public ByteBuffer 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 << 0);
198+ assert (off >= 0);
199+ return new DirectByteBuffer(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public ByteBuffer duplicate() {
203+ return new DirectByteBuffer(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public ByteBuffer asReadOnlyBuffer() {
212+
213+ return new DirectByteBufferR(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 << 0);
232+ }
233+
234+ public byte get() {
235+ return ((unsafe.getByte(ix(nextGetIndex()))));
236+ }
237+
238+ public byte get(int i) {
239+ return ((unsafe.getByte(ix(checkIndex(i)))));
240+ }
241+
242+ public ByteBuffer get(byte[] dst, int offset, int length) {
243+
244+ if ((length << 0) > 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+
255+
256+
257+
258+
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 0,
262+ length << 0);
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 ByteBuffer put(byte x) {
276+
277+ unsafe.putByte(ix(nextPutIndex()), ((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public ByteBuffer put(int i, byte x) {
285+
286+ unsafe.putByte(ix(checkIndex(i)), ((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public ByteBuffer put(ByteBuffer src) {
294+
295+ if (src instanceof DirectByteBuffer) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectByteBuffer sb = (DirectByteBuffer)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 << 0);
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 ByteBuffer put(byte[] src, int offset, int length) {
335+
336+ if ((length << 0) > 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+
347+
348+
349+
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 0,
352+ ix(pos), length << 0);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public ByteBuffer 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 << 0);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+
435+
436+
437+
438+
439+
440+
441+
442+
443+
444+
445+
446+
447+
448+
449+
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+
457+ unsafe.putByte(address + i, b);
458+
459+
460+
461+ }
462+
463+
464+
465+
466+ private char getChar(long a) {
467+ if (unaligned) {
468+ char x = unsafe.getChar(a);
469+ return (nativeByteOrder ? x : Bits.swap(x));
470+ }
471+ return Bits.getChar(a, bigEndian);
472+ }
473+
474+ public char getChar() {
475+ return getChar(ix(nextGetIndex((1 << 1))));
476+ }
477+
478+ public char getChar(int i) {
479+ return getChar(ix(checkIndex(i, (1 << 1))));
480+ }
481+
482+
483+
484+ private ByteBuffer putChar(long a, char x) {
485+
486+ if (unaligned) {
487+ char y = (x);
488+ unsafe.putChar(a, (nativeByteOrder ? y : Bits.swap(y)));
489+ } else {
490+ Bits.putChar(a, x, bigEndian);
491+ }
492+ return this;
493+
494+
495+
496+ }
497+
498+ public ByteBuffer putChar(char x) {
499+
500+ putChar(ix(nextPutIndex((1 << 1))), x);
501+ return this;
502+
503+
504+
505+ }
506+
507+ public ByteBuffer putChar(int i, char x) {
508+
509+ putChar(ix(checkIndex(i, (1 << 1))), x);
510+ return this;
511+
512+
513+
514+ }
515+
516+ public CharBuffer asCharBuffer() {
517+ int off = this.position();
518+ int lim = this.limit();
519+ assert (off <= lim);
520+ int rem = (off <= lim ? lim - off : 0);
521+
522+ int size = rem >> 1;
523+ if (!unaligned && ((address + off) % (1 << 1) != 0)) {
524+ return (bigEndian
525+ ? (CharBuffer)(new ByteBufferAsCharBufferB(this,
526+ -1,
527+ 0,
528+ size,
529+ size,
530+ off))
531+ : (CharBuffer)(new ByteBufferAsCharBufferL(this,
532+ -1,
533+ 0,
534+ size,
535+ size,
536+ off)));
537+ } else {
538+ return (nativeByteOrder
539+ ? (CharBuffer)(new DirectCharBufferU(this,
540+ -1,
541+ 0,
542+ size,
543+ size,
544+ off))
545+ : (CharBuffer)(new DirectCharBufferS(this,
546+ -1,
547+ 0,
548+ size,
549+ size,
550+ off)));
551+ }
552+ }
553+
554+
555+
556+
557+ private short getShort(long a) {
558+ if (unaligned) {
559+ short x = unsafe.getShort(a);
560+ return (nativeByteOrder ? x : Bits.swap(x));
561+ }
562+ return Bits.getShort(a, bigEndian);
563+ }
564+
565+ public short getShort() {
566+ return getShort(ix(nextGetIndex((1 << 1))));
567+ }
568+
569+ public short getShort(int i) {
570+ return getShort(ix(checkIndex(i, (1 << 1))));
571+ }
572+
573+
574+
575+ private ByteBuffer putShort(long a, short x) {
576+
577+ if (unaligned) {
578+ short y = (x);
579+ unsafe.putShort(a, (nativeByteOrder ? y : Bits.swap(y)));
580+ } else {
581+ Bits.putShort(a, x, bigEndian);
582+ }
583+ return this;
584+
585+
586+
587+ }
588+
589+ public ByteBuffer putShort(short x) {
590+
591+ putShort(ix(nextPutIndex((1 << 1))), x);
592+ return this;
593+
594+
595+
596+ }
597+
598+ public ByteBuffer putShort(int i, short x) {
599+
600+ putShort(ix(checkIndex(i, (1 << 1))), x);
601+ return this;
602+
603+
604+
605+ }
606+
607+ public ShortBuffer asShortBuffer() {
608+ int off = this.position();
609+ int lim = this.limit();
610+ assert (off <= lim);
611+ int rem = (off <= lim ? lim - off : 0);
612+
613+ int size = rem >> 1;
614+ if (!unaligned && ((address + off) % (1 << 1) != 0)) {
615+ return (bigEndian
616+ ? (ShortBuffer)(new ByteBufferAsShortBufferB(this,
617+ -1,
618+ 0,
619+ size,
620+ size,
621+ off))
622+ : (ShortBuffer)(new ByteBufferAsShortBufferL(this,
623+ -1,
624+ 0,
625+ size,
626+ size,
627+ off)));
628+ } else {
629+ return (nativeByteOrder
630+ ? (ShortBuffer)(new DirectShortBufferU(this,
631+ -1,
632+ 0,
633+ size,
634+ size,
635+ off))
636+ : (ShortBuffer)(new DirectShortBufferS(this,
637+ -1,
638+ 0,
639+ size,
640+ size,
641+ off)));
642+ }
643+ }
644+
645+
646+
647+
648+ private int getInt(long a) {
649+ if (unaligned) {
650+ int x = unsafe.getInt(a);
651+ return (nativeByteOrder ? x : Bits.swap(x));
652+ }
653+ return Bits.getInt(a, bigEndian);
654+ }
655+
656+ public int getInt() {
657+ return getInt(ix(nextGetIndex((1 << 2))));
658+ }
659+
660+ public int getInt(int i) {
661+ return getInt(ix(checkIndex(i, (1 << 2))));
662+ }
663+
664+
665+
666+ private ByteBuffer putInt(long a, int x) {
667+
668+ if (unaligned) {
669+ int y = (x);
670+ unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
671+ } else {
672+ Bits.putInt(a, x, bigEndian);
673+ }
674+ return this;
675+
676+
677+
678+ }
679+
680+ public ByteBuffer putInt(int x) {
681+
682+ putInt(ix(nextPutIndex((1 << 2))), x);
683+ return this;
684+
685+
686+
687+ }
688+
689+ public ByteBuffer putInt(int i, int x) {
690+
691+ putInt(ix(checkIndex(i, (1 << 2))), x);
692+ return this;
693+
694+
695+
696+ }
697+
698+ public IntBuffer asIntBuffer() {
699+ int off = this.position();
700+ int lim = this.limit();
701+ assert (off <= lim);
702+ int rem = (off <= lim ? lim - off : 0);
703+
704+ int size = rem >> 2;
705+ if (!unaligned && ((address + off) % (1 << 2) != 0)) {
706+ return (bigEndian
707+ ? (IntBuffer)(new ByteBufferAsIntBufferB(this,
708+ -1,
709+ 0,
710+ size,
711+ size,
712+ off))
713+ : (IntBuffer)(new ByteBufferAsIntBufferL(this,
714+ -1,
715+ 0,
716+ size,
717+ size,
718+ off)));
719+ } else {
720+ return (nativeByteOrder
721+ ? (IntBuffer)(new DirectIntBufferU(this,
722+ -1,
723+ 0,
724+ size,
725+ size,
726+ off))
727+ : (IntBuffer)(new DirectIntBufferS(this,
728+ -1,
729+ 0,
730+ size,
731+ size,
732+ off)));
733+ }
734+ }
735+
736+
737+
738+
739+ private long getLong(long a) {
740+ if (unaligned) {
741+ long x = unsafe.getLong(a);
742+ return (nativeByteOrder ? x : Bits.swap(x));
743+ }
744+ return Bits.getLong(a, bigEndian);
745+ }
746+
747+ public long getLong() {
748+ return getLong(ix(nextGetIndex((1 << 3))));
749+ }
750+
751+ public long getLong(int i) {
752+ return getLong(ix(checkIndex(i, (1 << 3))));
753+ }
754+
755+
756+
757+ private ByteBuffer putLong(long a, long x) {
758+
759+ if (unaligned) {
760+ long y = (x);
761+ unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
762+ } else {
763+ Bits.putLong(a, x, bigEndian);
764+ }
765+ return this;
766+
767+
768+
769+ }
770+
771+ public ByteBuffer putLong(long x) {
772+
773+ putLong(ix(nextPutIndex((1 << 3))), x);
774+ return this;
775+
776+
777+
778+ }
779+
780+ public ByteBuffer putLong(int i, long x) {
781+
782+ putLong(ix(checkIndex(i, (1 << 3))), x);
783+ return this;
784+
785+
786+
787+ }
788+
789+ public LongBuffer asLongBuffer() {
790+ int off = this.position();
791+ int lim = this.limit();
792+ assert (off <= lim);
793+ int rem = (off <= lim ? lim - off : 0);
794+
795+ int size = rem >> 3;
796+ if (!unaligned && ((address + off) % (1 << 3) != 0)) {
797+ return (bigEndian
798+ ? (LongBuffer)(new ByteBufferAsLongBufferB(this,
799+ -1,
800+ 0,
801+ size,
802+ size,
803+ off))
804+ : (LongBuffer)(new ByteBufferAsLongBufferL(this,
805+ -1,
806+ 0,
807+ size,
808+ size,
809+ off)));
810+ } else {
811+ return (nativeByteOrder
812+ ? (LongBuffer)(new DirectLongBufferU(this,
813+ -1,
814+ 0,
815+ size,
816+ size,
817+ off))
818+ : (LongBuffer)(new DirectLongBufferS(this,
819+ -1,
820+ 0,
821+ size,
822+ size,
823+ off)));
824+ }
825+ }
826+
827+
828+
829+
830+ private float getFloat(long a) {
831+ if (unaligned) {
832+ int x = unsafe.getInt(a);
833+ return Float.intBitsToFloat(nativeByteOrder ? x : Bits.swap(x));
834+ }
835+ return Bits.getFloat(a, bigEndian);
836+ }
837+
838+ public float getFloat() {
839+ return getFloat(ix(nextGetIndex((1 << 2))));
840+ }
841+
842+ public float getFloat(int i) {
843+ return getFloat(ix(checkIndex(i, (1 << 2))));
844+ }
845+
846+
847+
848+ private ByteBuffer putFloat(long a, float x) {
849+
850+ if (unaligned) {
851+ int y = Float.floatToRawIntBits(x);
852+ unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
853+ } else {
854+ Bits.putFloat(a, x, bigEndian);
855+ }
856+ return this;
857+
858+
859+
860+ }
861+
862+ public ByteBuffer putFloat(float x) {
863+
864+ putFloat(ix(nextPutIndex((1 << 2))), x);
865+ return this;
866+
867+
868+
869+ }
870+
871+ public ByteBuffer putFloat(int i, float x) {
872+
873+ putFloat(ix(checkIndex(i, (1 << 2))), x);
874+ return this;
875+
876+
877+
878+ }
879+
880+ public FloatBuffer asFloatBuffer() {
881+ int off = this.position();
882+ int lim = this.limit();
883+ assert (off <= lim);
884+ int rem = (off <= lim ? lim - off : 0);
885+
886+ int size = rem >> 2;
887+ if (!unaligned && ((address + off) % (1 << 2) != 0)) {
888+ return (bigEndian
889+ ? (FloatBuffer)(new ByteBufferAsFloatBufferB(this,
890+ -1,
891+ 0,
892+ size,
893+ size,
894+ off))
895+ : (FloatBuffer)(new ByteBufferAsFloatBufferL(this,
896+ -1,
897+ 0,
898+ size,
899+ size,
900+ off)));
901+ } else {
902+ return (nativeByteOrder
903+ ? (FloatBuffer)(new DirectFloatBufferU(this,
904+ -1,
905+ 0,
906+ size,
907+ size,
908+ off))
909+ : (FloatBuffer)(new DirectFloatBufferS(this,
910+ -1,
911+ 0,
912+ size,
913+ size,
914+ off)));
915+ }
916+ }
917+
918+
919+
920+
921+ private double getDouble(long a) {
922+ if (unaligned) {
923+ long x = unsafe.getLong(a);
924+ return Double.longBitsToDouble(nativeByteOrder ? x : Bits.swap(x));
925+ }
926+ return Bits.getDouble(a, bigEndian);
927+ }
928+
929+ public double getDouble() {
930+ return getDouble(ix(nextGetIndex((1 << 3))));
931+ }
932+
933+ public double getDouble(int i) {
934+ return getDouble(ix(checkIndex(i, (1 << 3))));
935+ }
936+
937+
938+
939+ private ByteBuffer putDouble(long a, double x) {
940+
941+ if (unaligned) {
942+ long y = Double.doubleToRawLongBits(x);
943+ unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
944+ } else {
945+ Bits.putDouble(a, x, bigEndian);
946+ }
947+ return this;
948+
949+
950+
951+ }
952+
953+ public ByteBuffer putDouble(double x) {
954+
955+ putDouble(ix(nextPutIndex((1 << 3))), x);
956+ return this;
957+
958+
959+
960+ }
961+
962+ public ByteBuffer putDouble(int i, double x) {
963+
964+ putDouble(ix(checkIndex(i, (1 << 3))), x);
965+ return this;
966+
967+
968+
969+ }
970+
971+ public DoubleBuffer asDoubleBuffer() {
972+ int off = this.position();
973+ int lim = this.limit();
974+ assert (off <= lim);
975+ int rem = (off <= lim ? lim - off : 0);
976+
977+ int size = rem >> 3;
978+ if (!unaligned && ((address + off) % (1 << 3) != 0)) {
979+ return (bigEndian
980+ ? (DoubleBuffer)(new ByteBufferAsDoubleBufferB(this,
981+ -1,
982+ 0,
983+ size,
984+ size,
985+ off))
986+ : (DoubleBuffer)(new ByteBufferAsDoubleBufferL(this,
987+ -1,
988+ 0,
989+ size,
990+ size,
991+ off)));
992+ } else {
993+ return (nativeByteOrder
994+ ? (DoubleBuffer)(new DirectDoubleBufferU(this,
995+ -1,
996+ 0,
997+ size,
998+ size,
999+ off))
1000+ : (DoubleBuffer)(new DirectDoubleBufferS(this,
1001+ -1,
1002+ 0,
1003+ size,
1004+ size,
1005+ off)));
1006+ }
1007+ }
1008+
1009+}
java/pkg/java/nio/DirectByteBufferR.java+1009−0
@@ -0,0 +1,1009 @@
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+
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 DirectByteBufferR
38+
39+
40+
41+ extends DirectByteBuffer
42+
43+ implements DirectBuffer
44+{
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+
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+ // Primary constructor
115+ //
116+ DirectByteBufferR(int cap) { // package-private
117+
118+
119+
120+
121+
122+
123+
124+
125+
126+
127+
128+
129+
130+
131+
132+
133+
134+
135+
136+
137+
138+
139+
140+ super(cap);
141+
142+ }
143+
144+
145+
146+
147+
148+
149+
150+
151+
152+
153+
154+
155+
156+ // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
157+ //
158+ protected DirectByteBufferR(int cap, long addr,
159+ FileDescriptor fd,
160+ Runnable unmapper)
161+ {
162+
163+
164+
165+
166+
167+
168+ super(cap, addr, fd, unmapper);
169+
170+ }
171+
172+
173+
174+ // For duplicates and slices
175+ //
176+ DirectByteBufferR(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public ByteBuffer 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 << 0);
198+ assert (off >= 0);
199+ return new DirectByteBufferR(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public ByteBuffer duplicate() {
203+ return new DirectByteBufferR(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public ByteBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public ByteBuffer put(byte x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public ByteBuffer put(int i, byte x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public ByteBuffer put(ByteBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public ByteBuffer put(byte[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public ByteBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+
435+
436+
437+
438+
439+
440+
441+
442+
443+
444+
445+
446+
447+
448+
449+
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+
457+
458+
459+ throw new ReadOnlyBufferException();
460+
461+ }
462+
463+
464+
465+
466+
467+
468+
469+
470+
471+
472+
473+
474+
475+
476+
477+
478+
479+
480+
481+
482+
483+
484+ private ByteBuffer putChar(long a, char x) {
485+
486+
487+
488+
489+
490+
491+
492+
493+
494+ throw new ReadOnlyBufferException();
495+
496+ }
497+
498+ public ByteBuffer putChar(char x) {
499+
500+
501+
502+
503+ throw new ReadOnlyBufferException();
504+
505+ }
506+
507+ public ByteBuffer putChar(int i, char x) {
508+
509+
510+
511+
512+ throw new ReadOnlyBufferException();
513+
514+ }
515+
516+ public CharBuffer asCharBuffer() {
517+ int off = this.position();
518+ int lim = this.limit();
519+ assert (off <= lim);
520+ int rem = (off <= lim ? lim - off : 0);
521+
522+ int size = rem >> 1;
523+ if (!unaligned && ((address + off) % (1 << 1) != 0)) {
524+ return (bigEndian
525+ ? (CharBuffer)(new ByteBufferAsCharBufferRB(this,
526+ -1,
527+ 0,
528+ size,
529+ size,
530+ off))
531+ : (CharBuffer)(new ByteBufferAsCharBufferRL(this,
532+ -1,
533+ 0,
534+ size,
535+ size,
536+ off)));
537+ } else {
538+ return (nativeByteOrder
539+ ? (CharBuffer)(new DirectCharBufferRU(this,
540+ -1,
541+ 0,
542+ size,
543+ size,
544+ off))
545+ : (CharBuffer)(new DirectCharBufferRS(this,
546+ -1,
547+ 0,
548+ size,
549+ size,
550+ off)));
551+ }
552+ }
553+
554+
555+
556+
557+
558+
559+
560+
561+
562+
563+
564+
565+
566+
567+
568+
569+
570+
571+
572+
573+
574+
575+ private ByteBuffer putShort(long a, short x) {
576+
577+
578+
579+
580+
581+
582+
583+
584+
585+ throw new ReadOnlyBufferException();
586+
587+ }
588+
589+ public ByteBuffer putShort(short x) {
590+
591+
592+
593+
594+ throw new ReadOnlyBufferException();
595+
596+ }
597+
598+ public ByteBuffer putShort(int i, short x) {
599+
600+
601+
602+
603+ throw new ReadOnlyBufferException();
604+
605+ }
606+
607+ public ShortBuffer asShortBuffer() {
608+ int off = this.position();
609+ int lim = this.limit();
610+ assert (off <= lim);
611+ int rem = (off <= lim ? lim - off : 0);
612+
613+ int size = rem >> 1;
614+ if (!unaligned && ((address + off) % (1 << 1) != 0)) {
615+ return (bigEndian
616+ ? (ShortBuffer)(new ByteBufferAsShortBufferRB(this,
617+ -1,
618+ 0,
619+ size,
620+ size,
621+ off))
622+ : (ShortBuffer)(new ByteBufferAsShortBufferRL(this,
623+ -1,
624+ 0,
625+ size,
626+ size,
627+ off)));
628+ } else {
629+ return (nativeByteOrder
630+ ? (ShortBuffer)(new DirectShortBufferRU(this,
631+ -1,
632+ 0,
633+ size,
634+ size,
635+ off))
636+ : (ShortBuffer)(new DirectShortBufferRS(this,
637+ -1,
638+ 0,
639+ size,
640+ size,
641+ off)));
642+ }
643+ }
644+
645+
646+
647+
648+
649+
650+
651+
652+
653+
654+
655+
656+
657+
658+
659+
660+
661+
662+
663+
664+
665+
666+ private ByteBuffer putInt(long a, int x) {
667+
668+
669+
670+
671+
672+
673+
674+
675+
676+ throw new ReadOnlyBufferException();
677+
678+ }
679+
680+ public ByteBuffer putInt(int x) {
681+
682+
683+
684+
685+ throw new ReadOnlyBufferException();
686+
687+ }
688+
689+ public ByteBuffer putInt(int i, int x) {
690+
691+
692+
693+
694+ throw new ReadOnlyBufferException();
695+
696+ }
697+
698+ public IntBuffer asIntBuffer() {
699+ int off = this.position();
700+ int lim = this.limit();
701+ assert (off <= lim);
702+ int rem = (off <= lim ? lim - off : 0);
703+
704+ int size = rem >> 2;
705+ if (!unaligned && ((address + off) % (1 << 2) != 0)) {
706+ return (bigEndian
707+ ? (IntBuffer)(new ByteBufferAsIntBufferRB(this,
708+ -1,
709+ 0,
710+ size,
711+ size,
712+ off))
713+ : (IntBuffer)(new ByteBufferAsIntBufferRL(this,
714+ -1,
715+ 0,
716+ size,
717+ size,
718+ off)));
719+ } else {
720+ return (nativeByteOrder
721+ ? (IntBuffer)(new DirectIntBufferRU(this,
722+ -1,
723+ 0,
724+ size,
725+ size,
726+ off))
727+ : (IntBuffer)(new DirectIntBufferRS(this,
728+ -1,
729+ 0,
730+ size,
731+ size,
732+ off)));
733+ }
734+ }
735+
736+
737+
738+
739+
740+
741+
742+
743+
744+
745+
746+
747+
748+
749+
750+
751+
752+
753+
754+
755+
756+
757+ private ByteBuffer putLong(long a, long x) {
758+
759+
760+
761+
762+
763+
764+
765+
766+
767+ throw new ReadOnlyBufferException();
768+
769+ }
770+
771+ public ByteBuffer putLong(long x) {
772+
773+
774+
775+
776+ throw new ReadOnlyBufferException();
777+
778+ }
779+
780+ public ByteBuffer putLong(int i, long x) {
781+
782+
783+
784+
785+ throw new ReadOnlyBufferException();
786+
787+ }
788+
789+ public LongBuffer asLongBuffer() {
790+ int off = this.position();
791+ int lim = this.limit();
792+ assert (off <= lim);
793+ int rem = (off <= lim ? lim - off : 0);
794+
795+ int size = rem >> 3;
796+ if (!unaligned && ((address + off) % (1 << 3) != 0)) {
797+ return (bigEndian
798+ ? (LongBuffer)(new ByteBufferAsLongBufferRB(this,
799+ -1,
800+ 0,
801+ size,
802+ size,
803+ off))
804+ : (LongBuffer)(new ByteBufferAsLongBufferRL(this,
805+ -1,
806+ 0,
807+ size,
808+ size,
809+ off)));
810+ } else {
811+ return (nativeByteOrder
812+ ? (LongBuffer)(new DirectLongBufferRU(this,
813+ -1,
814+ 0,
815+ size,
816+ size,
817+ off))
818+ : (LongBuffer)(new DirectLongBufferRS(this,
819+ -1,
820+ 0,
821+ size,
822+ size,
823+ off)));
824+ }
825+ }
826+
827+
828+
829+
830+
831+
832+
833+
834+
835+
836+
837+
838+
839+
840+
841+
842+
843+
844+
845+
846+
847+
848+ private ByteBuffer putFloat(long a, float x) {
849+
850+
851+
852+
853+
854+
855+
856+
857+
858+ throw new ReadOnlyBufferException();
859+
860+ }
861+
862+ public ByteBuffer putFloat(float x) {
863+
864+
865+
866+
867+ throw new ReadOnlyBufferException();
868+
869+ }
870+
871+ public ByteBuffer putFloat(int i, float x) {
872+
873+
874+
875+
876+ throw new ReadOnlyBufferException();
877+
878+ }
879+
880+ public FloatBuffer asFloatBuffer() {
881+ int off = this.position();
882+ int lim = this.limit();
883+ assert (off <= lim);
884+ int rem = (off <= lim ? lim - off : 0);
885+
886+ int size = rem >> 2;
887+ if (!unaligned && ((address + off) % (1 << 2) != 0)) {
888+ return (bigEndian
889+ ? (FloatBuffer)(new ByteBufferAsFloatBufferRB(this,
890+ -1,
891+ 0,
892+ size,
893+ size,
894+ off))
895+ : (FloatBuffer)(new ByteBufferAsFloatBufferRL(this,
896+ -1,
897+ 0,
898+ size,
899+ size,
900+ off)));
901+ } else {
902+ return (nativeByteOrder
903+ ? (FloatBuffer)(new DirectFloatBufferRU(this,
904+ -1,
905+ 0,
906+ size,
907+ size,
908+ off))
909+ : (FloatBuffer)(new DirectFloatBufferRS(this,
910+ -1,
911+ 0,
912+ size,
913+ size,
914+ off)));
915+ }
916+ }
917+
918+
919+
920+
921+
922+
923+
924+
925+
926+
927+
928+
929+
930+
931+
932+
933+
934+
935+
936+
937+
938+
939+ private ByteBuffer putDouble(long a, double x) {
940+
941+
942+
943+
944+
945+
946+
947+
948+
949+ throw new ReadOnlyBufferException();
950+
951+ }
952+
953+ public ByteBuffer putDouble(double x) {
954+
955+
956+
957+
958+ throw new ReadOnlyBufferException();
959+
960+ }
961+
962+ public ByteBuffer putDouble(int i, double x) {
963+
964+
965+
966+
967+ throw new ReadOnlyBufferException();
968+
969+ }
970+
971+ public DoubleBuffer asDoubleBuffer() {
972+ int off = this.position();
973+ int lim = this.limit();
974+ assert (off <= lim);
975+ int rem = (off <= lim ? lim - off : 0);
976+
977+ int size = rem >> 3;
978+ if (!unaligned && ((address + off) % (1 << 3) != 0)) {
979+ return (bigEndian
980+ ? (DoubleBuffer)(new ByteBufferAsDoubleBufferRB(this,
981+ -1,
982+ 0,
983+ size,
984+ size,
985+ off))
986+ : (DoubleBuffer)(new ByteBufferAsDoubleBufferRL(this,
987+ -1,
988+ 0,
989+ size,
990+ size,
991+ off)));
992+ } else {
993+ return (nativeByteOrder
994+ ? (DoubleBuffer)(new DirectDoubleBufferRU(this,
995+ -1,
996+ 0,
997+ size,
998+ size,
999+ off))
1000+ : (DoubleBuffer)(new DirectDoubleBufferRS(this,
1001+ -1,
1002+ 0,
1003+ size,
1004+ size,
1005+ off)));
1006+ }
1007+ }
1008+
1009+}
java/pkg/java/nio/DirectCharBufferRS.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+
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 DirectCharBufferRS
38+
39+
40+
41+ extends DirectCharBufferS
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectCharBufferRS(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
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 DirectCharBufferRS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public CharBuffer duplicate() {
203+ return new DirectCharBufferRS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public CharBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public CharBuffer put(char x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public CharBuffer put(int i, char x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public CharBuffer put(CharBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public CharBuffer put(char[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public CharBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
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 DirectCharBufferRS(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+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectCharBufferRU.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+
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 DirectCharBufferRU
38+
39+
40+
41+ extends DirectCharBufferU
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectCharBufferRU(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
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 DirectCharBufferRU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public CharBuffer duplicate() {
203+ return new DirectCharBufferRU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public CharBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public CharBuffer put(char x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public CharBuffer put(int i, char x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public CharBuffer put(CharBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public CharBuffer put(char[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public CharBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
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 DirectCharBufferRU(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+}
java/pkg/java/nio/DirectCharBufferS.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+
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 DirectCharBufferS
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+ DirectCharBufferS(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 DirectCharBufferS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public CharBuffer duplicate() {
203+ return new DirectCharBufferS(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 DirectCharBufferRS(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 (Bits.swap(unsafe.getChar(ix(nextGetIndex()))));
236+ }
237+
238+ public char get(int i) {
239+ return (Bits.swap(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()), Bits.swap((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public CharBuffer put(int i, char x) {
285+
286+ unsafe.putChar(ix(checkIndex(i)), Bits.swap((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public CharBuffer put(CharBuffer src) {
294+
295+ if (src instanceof DirectCharBufferS) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectCharBufferS sb = (DirectCharBufferS)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 DirectCharBufferS(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+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
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+
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 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+}
java/pkg/java/nio/DirectDoubleBufferRS.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+
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 DirectDoubleBufferRS
38+
39+
40+
41+ extends DirectDoubleBufferS
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectDoubleBufferRS(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public DoubleBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectDoubleBufferRS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public DoubleBuffer duplicate() {
203+ return new DirectDoubleBufferRS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public DoubleBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public DoubleBuffer put(double x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public DoubleBuffer put(int i, double x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public DoubleBuffer put(DoubleBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public DoubleBuffer put(double[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public DoubleBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectDoubleBufferRU.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+
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 DirectDoubleBufferRU
38+
39+
40+
41+ extends DirectDoubleBufferU
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectDoubleBufferRU(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public DoubleBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectDoubleBufferRU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public DoubleBuffer duplicate() {
203+ return new DirectDoubleBufferRU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public DoubleBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public DoubleBuffer put(double x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public DoubleBuffer put(int i, double x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public DoubleBuffer put(DoubleBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public DoubleBuffer put(double[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public DoubleBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectDoubleBufferS.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+
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 DirectDoubleBufferS
38+
39+ extends DoubleBuffer
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(double[].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+ DirectDoubleBufferS(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 DoubleBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectDoubleBufferS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public DoubleBuffer duplicate() {
203+ return new DirectDoubleBufferS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public DoubleBuffer asReadOnlyBuffer() {
212+
213+ return new DirectDoubleBufferRS(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 << 3);
232+ }
233+
234+ public double get() {
235+ return Double.longBitsToDouble(Bits.swap(unsafe.getLong(ix(nextGetIndex()))));
236+ }
237+
238+ public double get(int i) {
239+ return Double.longBitsToDouble(Bits.swap(unsafe.getLong(ix(checkIndex(i)))));
240+ }
241+
242+ public DoubleBuffer get(double[] dst, int offset, int length) {
243+
244+ if ((length << 3) > 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.copyToLongArray(ix(pos), dst,
256+ offset << 3,
257+ length << 3);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 3,
262+ length << 3);
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 DoubleBuffer put(double x) {
276+
277+ unsafe.putLong(ix(nextPutIndex()), Bits.swap(Double.doubleToRawLongBits(x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public DoubleBuffer put(int i, double x) {
285+
286+ unsafe.putLong(ix(checkIndex(i)), Bits.swap(Double.doubleToRawLongBits(x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public DoubleBuffer put(DoubleBuffer src) {
294+
295+ if (src instanceof DirectDoubleBufferS) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectDoubleBufferS sb = (DirectDoubleBufferS)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 << 3);
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 DoubleBuffer put(double[] src, int offset, int length) {
335+
336+ if ((length << 3) > 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.copyFromLongArray(src, offset << 3,
348+ ix(pos), length << 3);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 3,
352+ ix(pos), length << 3);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public DoubleBuffer 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 << 3);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectDoubleBufferU.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+
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 DirectDoubleBufferU
38+
39+ extends DoubleBuffer
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(double[].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+ DirectDoubleBufferU(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 DoubleBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectDoubleBufferU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public DoubleBuffer duplicate() {
203+ return new DirectDoubleBufferU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public DoubleBuffer asReadOnlyBuffer() {
212+
213+ return new DirectDoubleBufferRU(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 << 3);
232+ }
233+
234+ public double get() {
235+ return ((unsafe.getDouble(ix(nextGetIndex()))));
236+ }
237+
238+ public double get(int i) {
239+ return ((unsafe.getDouble(ix(checkIndex(i)))));
240+ }
241+
242+ public DoubleBuffer get(double[] dst, int offset, int length) {
243+
244+ if ((length << 3) > 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.copyToLongArray(ix(pos), dst,
256+ offset << 3,
257+ length << 3);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 3,
262+ length << 3);
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 DoubleBuffer put(double x) {
276+
277+ unsafe.putDouble(ix(nextPutIndex()), ((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public DoubleBuffer put(int i, double x) {
285+
286+ unsafe.putDouble(ix(checkIndex(i)), ((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public DoubleBuffer put(DoubleBuffer src) {
294+
295+ if (src instanceof DirectDoubleBufferU) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectDoubleBufferU sb = (DirectDoubleBufferU)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 << 3);
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 DoubleBuffer put(double[] src, int offset, int length) {
335+
336+ if ((length << 3) > 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.copyFromLongArray(src, offset << 3,
348+ ix(pos), length << 3);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 3,
352+ ix(pos), length << 3);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public DoubleBuffer 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 << 3);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectFloatBufferRS.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+
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 DirectFloatBufferRS
38+
39+
40+
41+ extends DirectFloatBufferS
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectFloatBufferRS(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public FloatBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectFloatBufferRS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public FloatBuffer duplicate() {
203+ return new DirectFloatBufferRS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public FloatBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public FloatBuffer put(float x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public FloatBuffer put(int i, float x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public FloatBuffer put(FloatBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public FloatBuffer put(float[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public FloatBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectFloatBufferRU.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+
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 DirectFloatBufferRU
38+
39+
40+
41+ extends DirectFloatBufferU
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectFloatBufferRU(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public FloatBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectFloatBufferRU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public FloatBuffer duplicate() {
203+ return new DirectFloatBufferRU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public FloatBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public FloatBuffer put(float x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public FloatBuffer put(int i, float x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public FloatBuffer put(FloatBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public FloatBuffer put(float[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public FloatBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectFloatBufferS.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+
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 DirectFloatBufferS
38+
39+ extends FloatBuffer
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(float[].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+ DirectFloatBufferS(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 FloatBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectFloatBufferS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public FloatBuffer duplicate() {
203+ return new DirectFloatBufferS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public FloatBuffer asReadOnlyBuffer() {
212+
213+ return new DirectFloatBufferRS(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 << 2);
232+ }
233+
234+ public float get() {
235+ return Float.intBitsToFloat(Bits.swap(unsafe.getInt(ix(nextGetIndex()))));
236+ }
237+
238+ public float get(int i) {
239+ return Float.intBitsToFloat(Bits.swap(unsafe.getInt(ix(checkIndex(i)))));
240+ }
241+
242+ public FloatBuffer get(float[] dst, int offset, int length) {
243+
244+ if ((length << 2) > 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.copyToIntArray(ix(pos), dst,
256+ offset << 2,
257+ length << 2);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 2,
262+ length << 2);
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 FloatBuffer put(float x) {
276+
277+ unsafe.putInt(ix(nextPutIndex()), Bits.swap(Float.floatToRawIntBits(x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public FloatBuffer put(int i, float x) {
285+
286+ unsafe.putInt(ix(checkIndex(i)), Bits.swap(Float.floatToRawIntBits(x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public FloatBuffer put(FloatBuffer src) {
294+
295+ if (src instanceof DirectFloatBufferS) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectFloatBufferS sb = (DirectFloatBufferS)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 << 2);
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 FloatBuffer put(float[] src, int offset, int length) {
335+
336+ if ((length << 2) > 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.copyFromIntArray(src, offset << 2,
348+ ix(pos), length << 2);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 2,
352+ ix(pos), length << 2);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public FloatBuffer 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 << 2);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectFloatBufferU.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+
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 DirectFloatBufferU
38+
39+ extends FloatBuffer
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(float[].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+ DirectFloatBufferU(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 FloatBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectFloatBufferU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public FloatBuffer duplicate() {
203+ return new DirectFloatBufferU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public FloatBuffer asReadOnlyBuffer() {
212+
213+ return new DirectFloatBufferRU(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 << 2);
232+ }
233+
234+ public float get() {
235+ return ((unsafe.getFloat(ix(nextGetIndex()))));
236+ }
237+
238+ public float get(int i) {
239+ return ((unsafe.getFloat(ix(checkIndex(i)))));
240+ }
241+
242+ public FloatBuffer get(float[] dst, int offset, int length) {
243+
244+ if ((length << 2) > 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.copyToIntArray(ix(pos), dst,
256+ offset << 2,
257+ length << 2);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 2,
262+ length << 2);
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 FloatBuffer put(float x) {
276+
277+ unsafe.putFloat(ix(nextPutIndex()), ((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public FloatBuffer put(int i, float x) {
285+
286+ unsafe.putFloat(ix(checkIndex(i)), ((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public FloatBuffer put(FloatBuffer src) {
294+
295+ if (src instanceof DirectFloatBufferU) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectFloatBufferU sb = (DirectFloatBufferU)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 << 2);
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 FloatBuffer put(float[] src, int offset, int length) {
335+
336+ if ((length << 2) > 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.copyFromIntArray(src, offset << 2,
348+ ix(pos), length << 2);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 2,
352+ ix(pos), length << 2);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public FloatBuffer 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 << 2);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectIntBufferRS.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+
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 DirectIntBufferRS
38+
39+
40+
41+ extends DirectIntBufferS
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectIntBufferRS(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public IntBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectIntBufferRS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public IntBuffer duplicate() {
203+ return new DirectIntBufferRS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public IntBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public IntBuffer put(int x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public IntBuffer put(int i, int x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public IntBuffer put(IntBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public IntBuffer put(int[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public IntBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectIntBufferRU.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+
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 DirectIntBufferRU
38+
39+
40+
41+ extends DirectIntBufferU
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectIntBufferRU(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public IntBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectIntBufferRU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public IntBuffer duplicate() {
203+ return new DirectIntBufferRU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public IntBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public IntBuffer put(int x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public IntBuffer put(int i, int x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public IntBuffer put(IntBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public IntBuffer put(int[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public IntBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectIntBufferS.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+
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 DirectIntBufferS
38+
39+ extends IntBuffer
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(int[].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+ DirectIntBufferS(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 IntBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectIntBufferS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public IntBuffer duplicate() {
203+ return new DirectIntBufferS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public IntBuffer asReadOnlyBuffer() {
212+
213+ return new DirectIntBufferRS(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 << 2);
232+ }
233+
234+ public int get() {
235+ return (Bits.swap(unsafe.getInt(ix(nextGetIndex()))));
236+ }
237+
238+ public int get(int i) {
239+ return (Bits.swap(unsafe.getInt(ix(checkIndex(i)))));
240+ }
241+
242+ public IntBuffer get(int[] dst, int offset, int length) {
243+
244+ if ((length << 2) > 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.copyToIntArray(ix(pos), dst,
256+ offset << 2,
257+ length << 2);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 2,
262+ length << 2);
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 IntBuffer put(int x) {
276+
277+ unsafe.putInt(ix(nextPutIndex()), Bits.swap((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public IntBuffer put(int i, int x) {
285+
286+ unsafe.putInt(ix(checkIndex(i)), Bits.swap((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public IntBuffer put(IntBuffer src) {
294+
295+ if (src instanceof DirectIntBufferS) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectIntBufferS sb = (DirectIntBufferS)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 << 2);
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 IntBuffer put(int[] src, int offset, int length) {
335+
336+ if ((length << 2) > 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.copyFromIntArray(src, offset << 2,
348+ ix(pos), length << 2);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 2,
352+ ix(pos), length << 2);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public IntBuffer 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 << 2);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectIntBufferU.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+
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 DirectIntBufferU
38+
39+ extends IntBuffer
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(int[].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+ DirectIntBufferU(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 IntBuffer 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 << 2);
198+ assert (off >= 0);
199+ return new DirectIntBufferU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public IntBuffer duplicate() {
203+ return new DirectIntBufferU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public IntBuffer asReadOnlyBuffer() {
212+
213+ return new DirectIntBufferRU(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 << 2);
232+ }
233+
234+ public int get() {
235+ return ((unsafe.getInt(ix(nextGetIndex()))));
236+ }
237+
238+ public int get(int i) {
239+ return ((unsafe.getInt(ix(checkIndex(i)))));
240+ }
241+
242+ public IntBuffer get(int[] dst, int offset, int length) {
243+
244+ if ((length << 2) > 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.copyToIntArray(ix(pos), dst,
256+ offset << 2,
257+ length << 2);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 2,
262+ length << 2);
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 IntBuffer put(int x) {
276+
277+ unsafe.putInt(ix(nextPutIndex()), ((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public IntBuffer put(int i, int x) {
285+
286+ unsafe.putInt(ix(checkIndex(i)), ((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public IntBuffer put(IntBuffer src) {
294+
295+ if (src instanceof DirectIntBufferU) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectIntBufferU sb = (DirectIntBufferU)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 << 2);
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 IntBuffer put(int[] src, int offset, int length) {
335+
336+ if ((length << 2) > 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.copyFromIntArray(src, offset << 2,
348+ ix(pos), length << 2);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 2,
352+ ix(pos), length << 2);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public IntBuffer 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 << 2);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectLongBufferRS.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+
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 DirectLongBufferRS
38+
39+
40+
41+ extends DirectLongBufferS
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectLongBufferRS(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public LongBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectLongBufferRS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public LongBuffer duplicate() {
203+ return new DirectLongBufferRS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public LongBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public LongBuffer put(long x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public LongBuffer put(int i, long x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public LongBuffer put(LongBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public LongBuffer put(long[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public LongBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectLongBufferRU.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+
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 DirectLongBufferRU
38+
39+
40+
41+ extends DirectLongBufferU
42+
43+ implements DirectBuffer
44+{
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+
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+
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+ DirectLongBufferRU(DirectBuffer db, // package-private
177+ int mark, int pos, int lim, int cap,
178+ int off)
179+ {
180+
181+
182+
183+
184+
185+
186+
187+
188+ super(db, mark, pos, lim, cap, off);
189+
190+ }
191+
192+ public LongBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectLongBufferRU(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public LongBuffer duplicate() {
203+ return new DirectLongBufferRU(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public LongBuffer asReadOnlyBuffer() {
212+
213+
214+
215+
216+
217+
218+
219+
220+ return duplicate();
221+
222+ }
223+
224+
225+
226+
227+
228+
229+
230+
231+
232+
233+
234+
235+
236+
237+
238+
239+
240+
241+
242+
243+
244+
245+
246+
247+
248+
249+
250+
251+
252+
253+
254+
255+
256+
257+
258+
259+
260+
261+
262+
263+
264+
265+
266+
267+
268+
269+
270+
271+
272+
273+
274+
275+ public LongBuffer put(long x) {
276+
277+
278+
279+
280+ throw new ReadOnlyBufferException();
281+
282+ }
283+
284+ public LongBuffer put(int i, long x) {
285+
286+
287+
288+
289+ throw new ReadOnlyBufferException();
290+
291+ }
292+
293+ public LongBuffer put(LongBuffer src) {
294+
295+
296+
297+
298+
299+
300+
301+
302+
303+
304+
305+
306+
307+
308+
309+
310+
311+
312+
313+
314+
315+
316+
317+
318+
319+
320+
321+
322+
323+
324+
325+
326+
327+
328+
329+
330+ throw new ReadOnlyBufferException();
331+
332+ }
333+
334+ public LongBuffer put(long[] src, int offset, int length) {
335+
336+
337+
338+
339+
340+
341+
342+
343+
344+
345+
346+
347+
348+
349+
350+
351+
352+
353+
354+
355+
356+
357+
358+
359+ throw new ReadOnlyBufferException();
360+
361+ }
362+
363+ public LongBuffer compact() {
364+
365+
366+
367+
368+
369+
370+
371+
372+
373+
374+
375+
376+ throw new ReadOnlyBufferException();
377+
378+ }
379+
380+ public boolean isDirect() {
381+ return true;
382+ }
383+
384+ public boolean isReadOnly() {
385+ return true;
386+ }
387+
388+
389+
390+
391+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ 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+}
java/pkg/java/nio/DirectLongBufferS.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+
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 DirectLongBufferS
38+
39+ extends LongBuffer
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(long[].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+ DirectLongBufferS(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 LongBuffer 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 << 3);
198+ assert (off >= 0);
199+ return new DirectLongBufferS(this, -1, 0, rem, rem, off);
200+ }
201+
202+ public LongBuffer duplicate() {
203+ return new DirectLongBufferS(this,
204+ this.markValue(),
205+ this.position(),
206+ this.limit(),
207+ this.capacity(),
208+ 0);
209+ }
210+
211+ public LongBuffer asReadOnlyBuffer() {
212+
213+ return new DirectLongBufferRS(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 << 3);
232+ }
233+
234+ public long get() {
235+ return (Bits.swap(unsafe.getLong(ix(nextGetIndex()))));
236+ }
237+
238+ public long get(int i) {
239+ return (Bits.swap(unsafe.getLong(ix(checkIndex(i)))));
240+ }
241+
242+ public LongBuffer get(long[] dst, int offset, int length) {
243+
244+ if ((length << 3) > 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.copyToLongArray(ix(pos), dst,
256+ offset << 3,
257+ length << 3);
258+ else
259+
260+ Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
261+ offset << 3,
262+ length << 3);
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 LongBuffer put(long x) {
276+
277+ unsafe.putLong(ix(nextPutIndex()), Bits.swap((x)));
278+ return this;
279+
280+
281+
282+ }
283+
284+ public LongBuffer put(int i, long x) {
285+
286+ unsafe.putLong(ix(checkIndex(i)), Bits.swap((x)));
287+ return this;
288+
289+
290+
291+ }
292+
293+ public LongBuffer put(LongBuffer src) {
294+
295+ if (src instanceof DirectLongBufferS) {
296+ if (src == this)
297+ throw new IllegalArgumentException();
298+ DirectLongBufferS sb = (DirectLongBufferS)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 << 3);
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 LongBuffer put(long[] src, int offset, int length) {
335+
336+ if ((length << 3) > 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.copyFromLongArray(src, offset << 3,
348+ ix(pos), length << 3);
349+ else
350+
351+ Bits.copyFromArray(src, arrayBaseOffset, offset << 3,
352+ ix(pos), length << 3);
353+ position(pos + length);
354+ } else {
355+ super.put(src, offset, length);
356+ }
357+ return this;
358+
359+
360+
361+ }
362+
363+ public LongBuffer 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 << 3);
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+
392+
393+
394+
395+
396+
397+
398+
399+
400+
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+ public ByteOrder order() {
435+
436+ return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
437+ ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
438+
439+
440+
441+
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+}
java/pkg/java/nio/DirectLongBufferU.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

459 more lines aren’t shown here.

java/pkg/java/nio/DirectShortBufferRS.java+470−0

This diff is large: its 471 lines aren’t shown here.

java/pkg/java/nio/DirectShortBufferRU.java+470−0

This diff is large: its 471 lines aren’t shown here.

java/pkg/java/nio/DirectShortBufferS.java+470−0

This diff is large: its 471 lines aren’t shown here.

java/pkg/java/nio/DirectShortBufferU.java+470−0

This diff is large: its 471 lines aren’t shown here.

java/pkg/java/nio/DoubleBuffer.java+1451−0

This diff is large: its 1452 lines aren’t shown here.

java/pkg/java/nio/FloatBuffer.java+1451−0

This diff is large: its 1452 lines aren’t shown here.

java/pkg/java/nio/HeapByteBuffer.java+602−0

This diff is large: its 603 lines aren’t shown here.

java/pkg/java/nio/HeapByteBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapCharBuffer.java+602−0

This diff is large: its 603 lines aren’t shown here.

java/pkg/java/nio/HeapCharBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapDoubleBuffer.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapDoubleBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapFloatBuffer.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapFloatBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapIntBuffer.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapIntBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapLongBuffer.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapLongBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapShortBuffer.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/HeapShortBufferR.java+595−0

This diff is large: its 596 lines aren’t shown here.

java/pkg/java/nio/IntBuffer.java+1451−0

This diff is large: its 1452 lines aren’t shown here.

java/pkg/java/nio/InvalidMarkException.java+51−0

This diff is large: its 52 lines aren’t shown here.

java/pkg/java/nio/LongBuffer.java+1451−0

This diff is large: its 1452 lines aren’t shown here.

java/pkg/java/nio/ReadOnlyBufferException.java+51−0

This diff is large: its 52 lines aren’t shown here.

java/pkg/java/nio/ShortBuffer.java+1451−0

This diff is large: its 1452 lines aren’t shown here.

java/pkg/java/nio/charset/CharacterCodingException.java+51−0

This diff is large: its 52 lines aren’t shown here.

java/pkg/java/nio/charset/Charset.java+13−9

This diff is large: its 29 lines aren’t shown here.

java/pkg/java/nio/charset/CharsetDecoder.java+972−0

This diff is large: its 973 lines aren’t shown here.

java/pkg/java/nio/charset/CharsetEncoder.java+972−0

This diff is large: its 973 lines aren’t shown here.

java/pkg/java/nio/charset/IllegalCharsetNameException.java+68−0

This diff is large: its 69 lines aren’t shown here.

java/pkg/java/nio/charset/UnsupportedCharsetException.java+68−0

This diff is large: its 69 lines aren’t shown here.