public NativeBytes(ObjectSerializer objectSerializer, long startAddr, long capacityAddr, AtomicInteger refCount) { super(objectSerializer, refCount); setStartPositionAddress(startAddr); this.limitAddr = this.capacityAddr = capacityAddr; positionChecks(positionAddr); }
@Override public NativeBytes slice(long offset, long length) { long sliceStart = positionAddr + offset; assert sliceStart >= startAddr && sliceStart < capacityAddr; long sliceEnd = sliceStart + length; assert sliceEnd > sliceStart && sliceEnd <= capacityAddr; return new NativeBytes(objectSerializer(), sliceStart, sliceEnd, refCount); }
void offsetChecks(long offset, long len) { assert actualOffsetChecks(offset, len); }
public NativeBytes(NativeBytes bytes) { super(bytes.objectSerializer(), new AtomicInteger(1)); setStartPositionAddress(bytes.startAddr); this.positionAddr = bytes.positionAddr; this.limitAddr = bytes.limitAddr; this.capacityAddr = bytes.capacityAddr; positionChecks(positionAddr); }
@Override public void readFully(@NotNull byte[] b, int off, int len) { checkArrayOffs(b.length, off, len); long left = remaining(); if (left < len) throw new IllegalStateException(new EOFException()); UNSAFE.copyMemory(null, positionAddr, b, BYTES_OFFSET + off, len); addPosition(len); }
void address(long address) { setStartPositionAddress(address); }
@Override public byte readByte() { byte aByte = UNSAFE.getByte(positionAddr); addPosition(1); return aByte; }
@Override public void write(byte[] bytes, int off, int len) { if (off < 0 || off + len > bytes.length || len > remaining()) throw new IllegalArgumentException(); UNSAFE.copyMemory(bytes, BYTES_OFFSET + off, null, positionAddr, len); addPosition(len); }
@Override public void write(long offset, @NotNull byte[] bytes) { if (offset < 0 || offset + bytes.length > capacity()) throw new IllegalArgumentException(); UNSAFE.copyMemory(bytes, BYTES_OFFSET, null, startAddr + offset, bytes.length); addPosition(bytes.length); }
@Override public long nextSetBit(long fromIndex) { if (fromIndex < 0) throw new IndexOutOfBoundsException(); long capacity = capacity(); long maxBit = capacity << 3; long fromLongIndex = fromIndex & ~63; if (fromLongIndex >= maxBit) return -1; long firstByte = fromLongIndex >>> 3; if ((fromIndex & 63) != 0) { long l = UNSAFE.getLongVolatile(null, startAddr + firstByte) >>> fromIndex; if (l != 0) { return fromIndex + numberOfTrailingZeros(l); } firstByte += 8; } if (capacity < Integer.MAX_VALUE) return nextSetBit0((int) firstByte, (int) capacity, startAddr); return nextSetBit0(firstByte, capacity, startAddr); }
public static NativeBytes wrap(long address, long capacity) { return new NativeBytes(address, address + capacity); }
@Override public void readFully(long offset, byte[] bytes, int off, int len) { checkArrayOffs(bytes.length, off, len); UNSAFE.copyMemory(null, startAddr + offset, bytes, BYTES_OFFSET + off, len); }
@Override public void close() { finished = true; releaseIndexBytes(); releaseDataBytes(); super.close(); }
void positionChecks(long positionAddr) { assert actualPositionChecks(positionAddr); }
@Override protected synchronized void cleanup() { if(!this.unmapped) { Cleaner cl = ((DirectBuffer)this.buffer).cleaner(); if (cl != null) { long start = System.nanoTime(); cl.clean(); fileLifecycleListener.onEvent( FileLifecycleListener.EventType.UNMAP, this.path, System.nanoTime() - start ); } try { if (this.channel != null && this.channel.isOpen()) { this.channel.close(); } } catch(IOException e) { throw new AssertionError(e); } this.unmapped = true; } super.cleanup(); }
@Override public void readFully(@NotNull byte[] b, int off, int len) { checkArrayOffs(b.length, off, len); long left = remaining(); if (left < len) throw new IllegalStateException(new EOFException()); UNSAFE.copyMemory(null, positionAddr, b, BYTES_OFFSET + off, len); addPosition(len); }
public NativeBytes(NativeBytes bytes) { super(bytes.objectSerializer(), new AtomicInteger(1)); setStartPositionAddress(bytes.startAddr); this.positionAddr = bytes.positionAddr; this.limitAddr = bytes.limitAddr; this.capacityAddr = bytes.capacityAddr; positionChecks(positionAddr); }
public NativeBytes(long startAddr, long capacityAddr) { super(); setStartPositionAddress(startAddr, capacityAddr); }