< prev index next >

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java

Print this page

106         return dup(offset, newSize, mask, owner, scope);
107     }
108 
109     @SuppressWarnings("unchecked")
110     public static <S extends MemorySegment> Spliterator<S> spliterator(S segment, SequenceLayout sequenceLayout) {
111         ((AbstractMemorySegmentImpl)segment).checkValidState();
112         if (sequenceLayout.byteSize() != segment.byteSize()) {
113             throw new IllegalArgumentException();
114         }
115         return (Spliterator<S>)new SegmentSplitter(sequenceLayout.elementLayout().byteSize(), sequenceLayout.elementCount().getAsLong(),
116                 (AbstractMemorySegmentImpl)segment.withAccessModes(segment.accessModes() & ~CLOSE));
117     }
118 
119     @Override
120     public final MemorySegment fill(byte value){
121         checkRange(0, length, true);
122         UNSAFE.setMemory(base(), min(), length, value);
123         return this;
124     }
125 











126     @Override
127     @ForceInline
128     public final MemoryAddress baseAddress() {
129         return new MemoryAddressImpl(this, 0);
130     }
131 
132     @Override
133     public final ByteBuffer asByteBuffer() {
134         if (!isSet(READ)) {
135             throw unsupportedAccessMode(READ);
136         }
137         checkIntSize("ByteBuffer");
138         ByteBuffer _bb = makeByteBuffer();
139         if (!isSet(WRITE)) {
140             //scope is IMMUTABLE - obtain a RO byte buffer
141             _bb = _bb.asReadOnlyBuffer();
142         }
143         return _bb;
144     }
145 

211         checkValidState();
212         closeNoCheck();
213     }
214 
215     private final void closeNoCheck() {
216         scope.close();
217     }
218 
219     final AbstractMemorySegmentImpl acquire() {
220         if (Thread.currentThread() != ownerThread() && !isSet(ACQUIRE)) {
221             throw unsupportedAccessMode(ACQUIRE);
222         }
223         return dup(0, length, mask, Thread.currentThread(), scope.acquire());
224     }
225 
226     @Override
227     public final byte[] toByteArray() {
228         checkIntSize("byte[]");
229         byte[] arr = new byte[(int)length];
230         MemorySegment arrSegment = MemorySegment.ofArray(arr);
231         MemoryAddress.copy(baseAddress(), arrSegment.baseAddress(), length);
232         return arr;
233     }
234 
235     boolean isSmall() {
236         return isSet(SMALL);
237     }
238 
239     void checkRange(long offset, long length, boolean writeAccess) {
240         checkValidState();
241         if (writeAccess && !isSet(WRITE)) {
242             throw unsupportedAccessMode(WRITE);
243         } else if (!writeAccess && !isSet(READ)) {
244             throw unsupportedAccessMode(READ);
245         }
246         checkBounds(offset, length);
247     }
248 
249     @Override
250     public final void checkValidState() {
251         if (owner != null && owner != Thread.currentThread()) {

106         return dup(offset, newSize, mask, owner, scope);
107     }
108 
109     @SuppressWarnings("unchecked")
110     public static <S extends MemorySegment> Spliterator<S> spliterator(S segment, SequenceLayout sequenceLayout) {
111         ((AbstractMemorySegmentImpl)segment).checkValidState();
112         if (sequenceLayout.byteSize() != segment.byteSize()) {
113             throw new IllegalArgumentException();
114         }
115         return (Spliterator<S>)new SegmentSplitter(sequenceLayout.elementLayout().byteSize(), sequenceLayout.elementCount().getAsLong(),
116                 (AbstractMemorySegmentImpl)segment.withAccessModes(segment.accessModes() & ~CLOSE));
117     }
118 
119     @Override
120     public final MemorySegment fill(byte value){
121         checkRange(0, length, true);
122         UNSAFE.setMemory(base(), min(), length, value);
123         return this;
124     }
125 
126     public void copyFrom(MemorySegment src) {
127         long size = src.byteSize();
128         ((AbstractMemorySegmentImpl)src).checkRange(0, size, true);
129         checkRange(0, size, false);
130         long offsetSrc = ((AbstractMemorySegmentImpl) src).min();
131         long offsetDst = min();
132         Object baseSrc = ((AbstractMemorySegmentImpl) src).base();
133         Object baseDst = base();
134         UNSAFE.copyMemory(baseSrc, offsetSrc, baseDst, offsetDst, size);
135     }
136 
137     @Override
138     @ForceInline
139     public final MemoryAddress baseAddress() {
140         return new MemoryAddressImpl(this, 0);
141     }
142 
143     @Override
144     public final ByteBuffer asByteBuffer() {
145         if (!isSet(READ)) {
146             throw unsupportedAccessMode(READ);
147         }
148         checkIntSize("ByteBuffer");
149         ByteBuffer _bb = makeByteBuffer();
150         if (!isSet(WRITE)) {
151             //scope is IMMUTABLE - obtain a RO byte buffer
152             _bb = _bb.asReadOnlyBuffer();
153         }
154         return _bb;
155     }
156 

222         checkValidState();
223         closeNoCheck();
224     }
225 
226     private final void closeNoCheck() {
227         scope.close();
228     }
229 
230     final AbstractMemorySegmentImpl acquire() {
231         if (Thread.currentThread() != ownerThread() && !isSet(ACQUIRE)) {
232             throw unsupportedAccessMode(ACQUIRE);
233         }
234         return dup(0, length, mask, Thread.currentThread(), scope.acquire());
235     }
236 
237     @Override
238     public final byte[] toByteArray() {
239         checkIntSize("byte[]");
240         byte[] arr = new byte[(int)length];
241         MemorySegment arrSegment = MemorySegment.ofArray(arr);
242         arrSegment.copyFrom(this);
243         return arr;
244     }
245 
246     boolean isSmall() {
247         return isSet(SMALL);
248     }
249 
250     void checkRange(long offset, long length, boolean writeAccess) {
251         checkValidState();
252         if (writeAccess && !isSet(WRITE)) {
253             throw unsupportedAccessMode(WRITE);
254         } else if (!writeAccess && !isSet(READ)) {
255             throw unsupportedAccessMode(READ);
256         }
257         checkBounds(offset, length);
258     }
259 
260     @Override
261     public final void checkValidState() {
262         if (owner != null && owner != Thread.currentThread()) {
< prev index next >