1 /*
2 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #warn This file is preprocessed before being compiled
27
28 package java.nio;
29
30 import java.util.Objects;
31 import jdk.internal.access.foreign.MemorySegmentProxy;
32 import jdk.internal.misc.Unsafe;
33
34 class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private
35 extends {#if[ro]?ByteBufferAs}$Type$Buffer{#if[ro]?$BO$}
36 {
37
38 #if[rw]
39
40 protected final ByteBuffer bb;
41
42 #end[rw]
43
44 ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb, MemorySegmentProxy segment) { // package-private
45 #if[rw]
46 super(-1, 0,
47 bb.remaining() >> $LG_BYTES_PER_VALUE$,
48 bb.remaining() >> $LG_BYTES_PER_VALUE$, segment);
49 this.bb = bb;
50 // enforce limit == capacity
51 int cap = this.capacity();
52 this.limit(cap);
53 int pos = this.position();
54 assert (pos <= cap);
55 address = bb.address;
56 #else[rw]
57 super(bb, segment);
58 #end[rw]
59 }
60
61 ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb,
62 int mark, int pos, int lim, int cap,
63 long addr, MemorySegmentProxy segment)
64 {
65 #if[rw]
66 super(mark, pos, lim, cap, segment);
67 this.bb = bb;
68 address = addr;
69 assert address >= bb.address;
70 #else[rw]
71 super(bb, mark, pos, lim, cap, addr, segment);
72 #end[rw]
73 }
74
75 @Override
76 Object base() {
77 return bb.hb;
78 }
79
80 public $Type$Buffer slice() {
81 int pos = this.position();
82 int lim = this.limit();
83 assert (pos <= lim);
84 int rem = (pos <= lim ? lim - pos : 0);
85 long addr = byteOffset(pos);
86 return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, -1, 0, rem, rem, addr, segment);
87 }
88
89 @Override
90 public $Type$Buffer slice(int index, int length) {
91 Objects.checkFromIndexSize(index, length, limit());
92 return new ByteBufferAs$Type$Buffer$RW$$BO$(bb,
93 -1,
94 0,
95 length,
96 length,
97 byteOffset(index), segment);
98 }
99
100 public $Type$Buffer duplicate() {
101 return new ByteBufferAs$Type$Buffer$RW$$BO$(bb,
102 this.markValue(),
103 this.position(),
104 this.limit(),
105 this.capacity(),
106 address, segment);
107 }
108
109 public $Type$Buffer asReadOnlyBuffer() {
110 #if[rw]
111 return new ByteBufferAs$Type$BufferR$BO$(bb,
112 this.markValue(),
113 this.position(),
114 this.limit(),
115 this.capacity(),
116 address, segment);
117 #else[rw]
118 return duplicate();
119 #end[rw]
120 }
121
122 #if[rw]
123
124 private int ix(int i) {
125 int off = (int) (address - bb.address);
126 return (i << $LG_BYTES_PER_VALUE$) + off;
127 }
128
129 protected long byteOffset(long i) {
130 return (i << $LG_BYTES_PER_VALUE$) + address;
131 }
132
133 public $type$ get() {
134 checkSegment();
135 $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(nextGetIndex()),
136 {#if[boB]?true:false});
137 return $fromBits$(x);
138 }
139
140 public $type$ get(int i) {
141 checkSegment();
142 $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)),
143 {#if[boB]?true:false});
144 return $fromBits$(x);
145 }
146
147 #if[streamableType]
148 $type$ getUnchecked(int i) {
149 $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(i),
150 {#if[boB]?true:false});
151 return $fromBits$(x);
152 }
153 #end[streamableType]
154
155 #end[rw]
156
157 public $Type$Buffer put($type$ x) {
158 #if[rw]
159 checkSegment();
160 $memtype$ y = $toBits$(x);
161 UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(nextPutIndex()), y,
162 {#if[boB]?true:false});
163 return this;
164 #else[rw]
165 throw new ReadOnlyBufferException();
166 #end[rw]
167 }
168
169 public $Type$Buffer put(int i, $type$ x) {
170 #if[rw]
171 checkSegment();
172 $memtype$ y = $toBits$(x);
173 UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)), y,
174 {#if[boB]?true:false});
175 return this;
176 #else[rw]
177 throw new ReadOnlyBufferException();
178 #end[rw]
179 }
180
181 public $Type$Buffer compact() {
182 #if[rw]
183 int pos = position();
184 int lim = limit();
185 assert (pos <= lim);
186 int rem = (pos <= lim ? lim - pos : 0);
187
188 ByteBuffer db = bb.duplicate();
189 db.limit(ix(lim));
190 db.position(ix(0));
191 ByteBuffer sb = db.slice();
192 sb.position(pos << $LG_BYTES_PER_VALUE$);
193 sb.compact();
194 position(rem);
195 limit(capacity());
196 discardMark();
197 return this;
198 #else[rw]
199 throw new ReadOnlyBufferException();
200 #end[rw]
201 }
202
203 public boolean isDirect() {
204 return bb.isDirect();
205 }
206
207 public boolean isReadOnly() {
208 return {#if[rw]?false:true};
209 }
210
211 #if[char]
212
213 public String toString(int start, int end) {
214 Objects.checkFromToIndex(start, end, limit());
215 try {
216 int len = end - start;
217 char[] ca = new char[len];
218 CharBuffer cb = CharBuffer.wrap(ca);
219 CharBuffer db = this.duplicate();
220 db.position(start);
221 db.limit(end);
222 cb.put(db);
223 return new String(ca);
224 } catch (StringIndexOutOfBoundsException x) {
225 throw new IndexOutOfBoundsException();
226 }
227 }
228
229
230 // --- Methods to support CharSequence ---
231
232 public CharBuffer subSequence(int start, int end) {
233 int pos = position();
234 int lim = limit();
235 assert (pos <= lim);
236 pos = (pos <= lim ? pos : lim);
237 int len = lim - pos;
238
239 Objects.checkFromToIndex(start, end, len);
240 return new ByteBufferAsCharBuffer$RW$$BO$(bb,
241 -1,
242 pos + start,
243 pos + end,
244 capacity(),
245 address, segment);
246 }
247
248 #end[char]
249
250
251 public ByteOrder order() {
252 #if[boB]
253 return ByteOrder.BIG_ENDIAN;
254 #end[boB]
255 #if[boL]
256 return ByteOrder.LITTLE_ENDIAN;
257 #end[boL]
258 }
259
260 #if[char]
261 ByteOrder charRegionOrder() {
262 return order();
263 }
264 #end[char]
265 }