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 package java.lang.foreign;
27
28 import java.lang.invoke.MethodHandles;
29 import java.lang.invoke.VarHandle;
30 import java.nio.ByteOrder;
31
32 import jdk.internal.foreign.layout.ValueLayouts;
33 import jdk.internal.javac.PreviewFeature;
34
35 /**
36 * A layout that models values of basic data types. Examples of values modelled by a value layout are
37 * <em>integral</em> values (either signed or unsigned), <em>floating-point</em> values and
38 * <em>address</em> values.
39 * <p>
40 * Each value layout has a size, an alignment (both expressed in bytes),
41 * a {@linkplain ByteOrder byte order}, and a <em>carrier</em>, that is, the Java type that should be used when
42 * {@linkplain MemorySegment#get(OfInt, long) accessing} a region of memory using the value layout.
43 * <p>
44 * This class defines useful value layout constants for Java primitive types and addresses.
45 * @apiNote Some characteristics of the Java layout constants are platform-dependent. For instance, the byte order of
46 * these constants is set to the {@linkplain ByteOrder#nativeOrder() native byte order}, thus making it easy to work
47 * with other APIs, such as arrays and {@link java.nio.ByteBuffer}. Moreover, the alignment constraint of
48 * {@link ValueLayout#JAVA_LONG} and {@link ValueLayout#JAVA_DOUBLE} is set to 8 bytes on 64-bit platforms, but only to
49 * 4 bytes on 32-bit platforms.
50 *
51 * @implSpec implementing classes and subclasses are immutable, thread-safe and <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.
52 *
53 * @sealedGraph
54 * @since 19
55 */
56 @PreviewFeature(feature=PreviewFeature.Feature.FOREIGN)
57 public sealed interface ValueLayout extends MemoryLayout permits
58 ValueLayout.OfBoolean, ValueLayout.OfByte, ValueLayout.OfChar, ValueLayout.OfShort, ValueLayout.OfInt,
59 ValueLayout.OfFloat, ValueLayout.OfLong, ValueLayout.OfDouble, AddressLayout {
60
61 /**
62 * {@return the value's byte order}
63 */
64 ByteOrder order();
65
66 /**
67 * {@return a value layout with the same characteristics as this layout, but with the given byte order}
68 *
69 * @param order the desired byte order.
70 */
71 ValueLayout withOrder(ByteOrder order);
72
73 /**
74 * {@inheritDoc}
75 */
76 @Override
77 ValueLayout withoutName();
78
79 /**
80 * Creates a <em>strided</em> var handle that can be used to access a memory segment as multi-dimensional
81 * array. This array has a notional sequence layout featuring {@code shape.length} nested sequence layouts. The element
82 * layout of the innermost sequence layout in the notional sequence layout is this value layout. The resulting var handle
83 * is obtained as if calling the {@link #varHandle(PathElement...)} method on the notional layout, with a layout
84 * path containing exactly {@code shape.length + 1} {@linkplain PathElement#sequenceElement() open sequence layout path elements}.
85 * <p>
86 * For instance, the following method call:
87 *
88 * {@snippet lang=java :
89 * VarHandle arrayHandle = ValueLayout.JAVA_INT.arrayElementVarHandle(10, 20);
90 * }
91 *
92 * Is equivalent to the following code:
93 *
94 * {@snippet lang = java:
95 * SequenceLayout notionalLayout = MemoryLayout.sequenceLayout(
96 * MemoryLayout.sequenceLayout(10, MemoryLayout.sequenceLayout(20, ValueLayout.JAVA_INT)));
97 * VarHandle arrayHandle = notionalLayout.varHandle(PathElement.sequenceElement(),
98 * PathElement.sequenceElement(),
99 * PathElement.sequenceElement());
100 *}
101 *
102 * The resulting var handle {@code arrayHandle} will feature 3 coordinates of type {@code long}; each coordinate
103 * is interpreted as an index into the corresponding sequence layout. If we refer to the var handle coordinates, from left
104 * to right, as {@code x}, {@code y} and {@code z} respectively, the final offset accessed by the var handle can be
105 * computed with the following formula:
106 *
107 * <blockquote><pre>{@code
108 * offset = (10 * 20 * 4 * x) + (20 * 4 * y) + (4 * z)
109 * }</pre></blockquote>
110 *
111 * Additionally, the values of {@code x}, {@code y} and {@code z} are constrained as follows:
112 * <ul>
113 * <li>{@code 0 <= x < notionalLayout.elementCount() }</li>
114 * <li>{@code 0 <= y < 10 }</li>
115 * <li>{@code 0 <= z < 20 }</li>
116 * </ul>
117 * <p>
118 * Consider the following access expressions:
119 * {@snippet lang=java :
120 * int value1 = (int) arrayHandle.get(10, 2, 4); // ok, accessed offset = 8176
121 * int value2 = (int) arrayHandle.get(0, 0, 30); // out of bounds value for z
122 * }
123 * In the first case, access is well-formed, as the values for {@code x}, {@code y} and {@code z} conform to
124 * the bounds specified above. In the second case, access fails with {@link IndexOutOfBoundsException},
125 * as the value for {@code z} is outside its specified bounds.
126 *
127 * @param shape the size of each nested array dimension.
128 * @return a var handle which can be used to access a memory segment as a multi-dimensional array,
129 * featuring {@code shape.length + 1}
130 * {@code long} coordinates.
131 * @throws IllegalArgumentException if {@code shape[i] < 0}, for at least one index {@code i}.
132 * @throws UnsupportedOperationException if {@code byteAlignment() > byteSize()}.
133 * @see MethodHandles#memorySegmentViewVarHandle
134 * @see MemoryLayout#varHandle(PathElement...)
135 * @see SequenceLayout
136 */
137 VarHandle arrayElementVarHandle(int... shape);
138
139 /**
140 * {@return the carrier associated with this value layout}
141 */
142 Class<?> carrier();
143
144 /**
145 * {@inheritDoc}
146 */
147 @Override
148 ValueLayout withName(String name);
149
150 /**
151 * {@inheritDoc}
152 * @throws IllegalArgumentException {@inheritDoc}
153 */
154 @Override
155 ValueLayout withByteAlignment(long byteAlignment);
156
157 /**
158 * A value layout whose carrier is {@code boolean.class}.
159 *
160 * @see #JAVA_BOOLEAN
161 * @since 19
162 */
163 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
164 sealed interface OfBoolean extends ValueLayout permits ValueLayouts.OfBooleanImpl {
165
166 /**
167 * {@inheritDoc}
168 */
169 @Override
170 OfBoolean withName(String name);
171
172 /**
173 * {@inheritDoc}
174 */
175 @Override
176 OfBoolean withoutName();
177
178 /**
179 * {@inheritDoc}
180 * @throws IllegalArgumentException {@inheritDoc}
181 */
182 @Override
183 OfBoolean withByteAlignment(long byteAlignment);
184
185 /**
186 * {@inheritDoc}
187 */
188 @Override
189 OfBoolean withOrder(ByteOrder order);
190
191 }
192
193 /**
194 * A value layout whose carrier is {@code byte.class}.
195 *
196 * @see #JAVA_BYTE
197 * @since 19
198 */
199 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
200 sealed interface OfByte extends ValueLayout permits ValueLayouts.OfByteImpl {
201
202 /**
203 * {@inheritDoc}
204 */
205 @Override
206 OfByte withName(String name);
207
208 /**
209 * {@inheritDoc}
210 */
211 @Override
212 OfByte withoutName();
213
214 /**
215 * {@inheritDoc}
216 * @throws IllegalArgumentException {@inheritDoc}
217 */
218 @Override
219 OfByte withByteAlignment(long byteAlignment);
220
221 /**
222 * {@inheritDoc}
223 */
224 @Override
225 OfByte withOrder(ByteOrder order);
226
227 }
228
229 /**
230 * A value layout whose carrier is {@code char.class}.
231 *
232 * @see #JAVA_CHAR
233 * @see #JAVA_CHAR_UNALIGNED
234 * @since 19
235 */
236 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
237 sealed interface OfChar extends ValueLayout permits ValueLayouts.OfCharImpl {
238
239 /**
240 * {@inheritDoc}
241 */
242 @Override
243 OfChar withName(String name);
244
245 /**
246 * {@inheritDoc}
247 */
248 @Override
249 OfChar withoutName();
250
251 /**
252 * {@inheritDoc}
253 * @throws IllegalArgumentException {@inheritDoc}
254 */
255 @Override
256 OfChar withByteAlignment(long byteAlignment);
257
258 /**
259 * {@inheritDoc}
260 */
261 @Override
262 OfChar withOrder(ByteOrder order);
263
264 }
265
266 /**
267 * A value layout whose carrier is {@code short.class}.
268 *
269 * @see #JAVA_SHORT
270 * @see #JAVA_SHORT_UNALIGNED
271 * @since 19
272 */
273 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
274 sealed interface OfShort extends ValueLayout permits ValueLayouts.OfShortImpl {
275
276 /**
277 * {@inheritDoc}
278 */
279 @Override
280 OfShort withName(String name);
281
282 /**
283 * {@inheritDoc}
284 */
285 @Override
286 OfShort withoutName();
287
288 /**
289 * {@inheritDoc}
290 * @throws IllegalArgumentException {@inheritDoc}
291 */
292 @Override
293 OfShort withByteAlignment(long byteAlignment);
294
295 /**
296 * {@inheritDoc}
297 */
298 @Override
299 OfShort withOrder(ByteOrder order);
300
301 }
302
303 /**
304 * A value layout whose carrier is {@code int.class}.
305 *
306 * @see #JAVA_INT
307 * @see #JAVA_INT_UNALIGNED
308 * @since 19
309 */
310 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
311 sealed interface OfInt extends ValueLayout permits ValueLayouts.OfIntImpl {
312
313 /**
314 * {@inheritDoc}
315 */
316 @Override
317 OfInt withName(String name);
318
319 /**
320 * {@inheritDoc}
321 */
322 @Override
323 OfInt withoutName();
324
325 /**
326 * {@inheritDoc}
327 * @throws IllegalArgumentException {@inheritDoc}
328 */
329 @Override
330 OfInt withByteAlignment(long byteAlignment);
331
332 /**
333 * {@inheritDoc}
334 */
335 @Override
336 OfInt withOrder(ByteOrder order);
337
338 }
339
340 /**
341 * A value layout whose carrier is {@code float.class}.
342 *
343 * @see #JAVA_FLOAT
344 * @see #JAVA_FLOAT_UNALIGNED
345 * @since 19
346 */
347 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
348 sealed interface OfFloat extends ValueLayout permits ValueLayouts.OfFloatImpl {
349
350 /**
351 * {@inheritDoc}
352 */
353 @Override
354 OfFloat withName(String name);
355
356 /**
357 * {@inheritDoc}
358 */
359 @Override
360 OfFloat withoutName();
361
362 /**
363 * {@inheritDoc}
364 */
365 @Override
366 OfFloat withByteAlignment(long byteAlignment);
367
368 /**
369 * {@inheritDoc}
370 */
371 @Override
372 OfFloat withOrder(ByteOrder order);
373
374 }
375
376 /**
377 * A value layout whose carrier is {@code long.class}.
378 *
379 * @see #JAVA_LONG
380 * @see #JAVA_LONG_UNALIGNED
381 * @since 19
382 */
383 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
384 sealed interface OfLong extends ValueLayout permits ValueLayouts.OfLongImpl {
385
386 /**
387 * {@inheritDoc}
388 */
389 @Override
390 OfLong withName(String name);
391
392 /**
393 * {@inheritDoc}
394 */
395 @Override
396 OfLong withoutName();
397
398 /**
399 * {@inheritDoc}
400 * @throws IllegalArgumentException {@inheritDoc}
401 */
402 @Override
403 OfLong withByteAlignment(long byteAlignment);
404
405 /**
406 * {@inheritDoc}
407 */
408 @Override
409 OfLong withOrder(ByteOrder order);
410
411 }
412
413 /**
414 * A value layout whose carrier is {@code double.class}.
415 *
416 * @see #JAVA_DOUBLE
417 * @see #JAVA_DOUBLE_UNALIGNED
418 * @since 19
419 */
420 @PreviewFeature(feature = PreviewFeature.Feature.FOREIGN)
421 sealed interface OfDouble extends ValueLayout permits ValueLayouts.OfDoubleImpl {
422
423 /**
424 * {@inheritDoc}
425 */
426 @Override
427 OfDouble withName(String name);
428
429 /**
430 * {@inheritDoc}
431 */
432 @Override
433 OfDouble withoutName();
434
435 /**
436 * {@inheritDoc}
437 * @throws IllegalArgumentException {@inheritDoc}
438 */
439 @Override
440 OfDouble withByteAlignment(long byteAlignment);
441
|
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 package java.lang.foreign;
27
28 import java.lang.invoke.VarHandle;
29 import java.nio.ByteOrder;
30 import jdk.internal.foreign.layout.ValueLayouts;
31
32 /**
33 * A layout that models values of basic data types. Examples of values modelled by a value layout are
34 * <em>integral</em> values (either signed or unsigned), <em>floating-point</em> values and
35 * <em>address</em> values.
36 * <p>
37 * Each value layout has a size, an alignment (both expressed in bytes),
38 * a {@linkplain ByteOrder byte order}, and a <em>carrier</em>, that is, the Java type that should be used when
39 * {@linkplain MemorySegment#get(OfInt, long) accessing} a region of memory using the value layout.
40 * <p>
41 * This class defines useful value layout constants for Java primitive types and addresses.
42 * @apiNote Some characteristics of the Java layout constants are platform-dependent. For instance, the byte order of
43 * these constants is set to the {@linkplain ByteOrder#nativeOrder() native byte order}, thus making it easy to work
44 * with other APIs, such as arrays and {@link java.nio.ByteBuffer}. Moreover, the alignment constraint of
45 * {@link ValueLayout#JAVA_LONG} and {@link ValueLayout#JAVA_DOUBLE} is set to 8 bytes on 64-bit platforms, but only to
46 * 4 bytes on 32-bit platforms.
47 *
48 * @implSpec implementing classes and subclasses are immutable, thread-safe and <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a>.
49 *
50 * @sealedGraph
51 * @since 22
52 */
53 public sealed interface ValueLayout extends MemoryLayout permits
54 ValueLayout.OfBoolean, ValueLayout.OfByte, ValueLayout.OfChar, ValueLayout.OfShort, ValueLayout.OfInt,
55 ValueLayout.OfFloat, ValueLayout.OfLong, ValueLayout.OfDouble, AddressLayout {
56
57 /**
58 * {@return the value's byte order}
59 */
60 ByteOrder order();
61
62 /**
63 * {@return a value layout with the same characteristics as this layout, but with the given byte order}
64 *
65 * @param order the desired byte order.
66 */
67 ValueLayout withOrder(ByteOrder order);
68
69 /**
70 * {@inheritDoc}
71 */
72 @Override
73 ValueLayout withoutName();
74
75 /**
76 * {@return the carrier associated with this value layout}
77 */
78 Class<?> carrier();
79
80 /**
81 * {@inheritDoc}
82 */
83 @Override
84 ValueLayout withName(String name);
85
86 /**
87 * {@inheritDoc}
88 *
89 * @throws IllegalArgumentException {@inheritDoc}
90 */
91 @Override
92 ValueLayout withByteAlignment(long byteAlignment);
93
94 /**
95 * {@return a var handle which can be used to access values described by this value layout, in a given memory segment.}
96 * <p>
97 * The returned var handle's {@linkplain VarHandle#varType() var type} is the {@linkplain ValueLayout#carrier() carrier type} of
98 * this value layout, and the list of coordinate types is {@code (MemorySegment, long)}, where the memory segment coordinate
99 * corresponds to the memory segment to be accessed, and the {@code long} coordinate corresponds to the byte offset
100 * into the accessed memory segment at which the access occurs.
101 * <p>
102 * The returned var handle checks that accesses are aligned according to this value layout's
103 * {@linkplain MemoryLayout#byteAlignment() alignment constraint}.
104 *
105 * @apiNote This method is similar, but more efficient, than calling {@code MemoryLayout#varHandle(PathElement...)}
106 * with an empty path element array, as it avoids the creation of the var args array.
107 *
108 * @apiNote The returned var handle features certain <a href="MemoryLayout.html#access-mode-restrictions">access mode
109 * restrictions</a> common to all memory access var handles derived from memory layouts.
110 *
111 * @see MemoryLayout#varHandle(PathElement...)
112 */
113 VarHandle varHandle();
114
115 /**
116 * A value layout whose carrier is {@code boolean.class}.
117 *
118 * @see #JAVA_BOOLEAN
119 * @since 22
120 */
121 sealed interface OfBoolean extends ValueLayout permits ValueLayouts.OfBooleanImpl {
122
123 /**
124 * {@inheritDoc}
125 */
126 @Override
127 OfBoolean withName(String name);
128
129 /**
130 * {@inheritDoc}
131 */
132 @Override
133 OfBoolean withoutName();
134
135 /**
136 * {@inheritDoc}
137 * @throws IllegalArgumentException {@inheritDoc}
138 */
139 @Override
140 OfBoolean withByteAlignment(long byteAlignment);
141
142 /**
143 * {@inheritDoc}
144 */
145 @Override
146 OfBoolean withOrder(ByteOrder order);
147
148 }
149
150 /**
151 * A value layout whose carrier is {@code byte.class}.
152 *
153 * @see #JAVA_BYTE
154 * @since 22
155 */
156 sealed interface OfByte extends ValueLayout permits ValueLayouts.OfByteImpl {
157
158 /**
159 * {@inheritDoc}
160 */
161 @Override
162 OfByte withName(String name);
163
164 /**
165 * {@inheritDoc}
166 */
167 @Override
168 OfByte withoutName();
169
170 /**
171 * {@inheritDoc}
172 * @throws IllegalArgumentException {@inheritDoc}
173 */
174 @Override
175 OfByte withByteAlignment(long byteAlignment);
176
177 /**
178 * {@inheritDoc}
179 */
180 @Override
181 OfByte withOrder(ByteOrder order);
182
183 }
184
185 /**
186 * A value layout whose carrier is {@code char.class}.
187 *
188 * @see #JAVA_CHAR
189 * @see #JAVA_CHAR_UNALIGNED
190 * @since 22
191 */
192 sealed interface OfChar extends ValueLayout permits ValueLayouts.OfCharImpl {
193
194 /**
195 * {@inheritDoc}
196 */
197 @Override
198 OfChar withName(String name);
199
200 /**
201 * {@inheritDoc}
202 */
203 @Override
204 OfChar withoutName();
205
206 /**
207 * {@inheritDoc}
208 * @throws IllegalArgumentException {@inheritDoc}
209 */
210 @Override
211 OfChar withByteAlignment(long byteAlignment);
212
213 /**
214 * {@inheritDoc}
215 */
216 @Override
217 OfChar withOrder(ByteOrder order);
218
219 }
220
221 /**
222 * A value layout whose carrier is {@code short.class}.
223 *
224 * @see #JAVA_SHORT
225 * @see #JAVA_SHORT_UNALIGNED
226 * @since 22
227 */
228 sealed interface OfShort extends ValueLayout permits ValueLayouts.OfShortImpl {
229
230 /**
231 * {@inheritDoc}
232 */
233 @Override
234 OfShort withName(String name);
235
236 /**
237 * {@inheritDoc}
238 */
239 @Override
240 OfShort withoutName();
241
242 /**
243 * {@inheritDoc}
244 * @throws IllegalArgumentException {@inheritDoc}
245 */
246 @Override
247 OfShort withByteAlignment(long byteAlignment);
248
249 /**
250 * {@inheritDoc}
251 */
252 @Override
253 OfShort withOrder(ByteOrder order);
254
255 }
256
257 /**
258 * A value layout whose carrier is {@code int.class}.
259 *
260 * @see #JAVA_INT
261 * @see #JAVA_INT_UNALIGNED
262 * @since 22
263 */
264 sealed interface OfInt extends ValueLayout permits ValueLayouts.OfIntImpl {
265
266 /**
267 * {@inheritDoc}
268 */
269 @Override
270 OfInt withName(String name);
271
272 /**
273 * {@inheritDoc}
274 */
275 @Override
276 OfInt withoutName();
277
278 /**
279 * {@inheritDoc}
280 * @throws IllegalArgumentException {@inheritDoc}
281 */
282 @Override
283 OfInt withByteAlignment(long byteAlignment);
284
285 /**
286 * {@inheritDoc}
287 */
288 @Override
289 OfInt withOrder(ByteOrder order);
290
291 }
292
293 /**
294 * A value layout whose carrier is {@code float.class}.
295 *
296 * @see #JAVA_FLOAT
297 * @see #JAVA_FLOAT_UNALIGNED
298 * @since 22
299 */
300 sealed interface OfFloat extends ValueLayout permits ValueLayouts.OfFloatImpl {
301
302 /**
303 * {@inheritDoc}
304 */
305 @Override
306 OfFloat withName(String name);
307
308 /**
309 * {@inheritDoc}
310 */
311 @Override
312 OfFloat withoutName();
313
314 /**
315 * {@inheritDoc}
316 */
317 @Override
318 OfFloat withByteAlignment(long byteAlignment);
319
320 /**
321 * {@inheritDoc}
322 */
323 @Override
324 OfFloat withOrder(ByteOrder order);
325
326 }
327
328 /**
329 * A value layout whose carrier is {@code long.class}.
330 *
331 * @see #JAVA_LONG
332 * @see #JAVA_LONG_UNALIGNED
333 * @since 22
334 */
335 sealed interface OfLong extends ValueLayout permits ValueLayouts.OfLongImpl {
336
337 /**
338 * {@inheritDoc}
339 */
340 @Override
341 OfLong withName(String name);
342
343 /**
344 * {@inheritDoc}
345 */
346 @Override
347 OfLong withoutName();
348
349 /**
350 * {@inheritDoc}
351 * @throws IllegalArgumentException {@inheritDoc}
352 */
353 @Override
354 OfLong withByteAlignment(long byteAlignment);
355
356 /**
357 * {@inheritDoc}
358 */
359 @Override
360 OfLong withOrder(ByteOrder order);
361
362 }
363
364 /**
365 * A value layout whose carrier is {@code double.class}.
366 *
367 * @see #JAVA_DOUBLE
368 * @see #JAVA_DOUBLE_UNALIGNED
369 * @since 22
370 */
371 sealed interface OfDouble extends ValueLayout permits ValueLayouts.OfDoubleImpl {
372
373 /**
374 * {@inheritDoc}
375 */
376 @Override
377 OfDouble withName(String name);
378
379 /**
380 * {@inheritDoc}
381 */
382 @Override
383 OfDouble withoutName();
384
385 /**
386 * {@inheritDoc}
387 * @throws IllegalArgumentException {@inheritDoc}
388 */
389 @Override
390 OfDouble withByteAlignment(long byteAlignment);
391
|