Java Code Examples for io.netty.util.internal.PlatformDependent#copyMemory()

public ByteBuf setBytes(int index, ByteBuffer src, int srcIndex, int length) {
  if (src.isDirect()) {
    checkIndex(index, length);
    PlatformDependent.copyMemory(PlatformDependent.directBufferAddress(src) + srcIndex, this.memoryAddress() + index,
        length);
  } else {
    if (srcIndex == 0 && src.capacity() == length) {
      udle.setBytes(index + offset, src);
    } else {
      ByteBuffer newBuf = src.duplicate();
      newBuf.position(srcIndex);
      newBuf.limit(srcIndex + length);
      udle.setBytes(index + offset, src);
    }
  }

  return this;
}
 

@Override
public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
    checkIndex(index, length);
    if (src == null) {
        throw new NullPointerException("src");
    }
    if (srcIndex < 0 || srcIndex > src.capacity() - length) {
        throw new IndexOutOfBoundsException("srcIndex: " + srcIndex);
    }

    if (length != 0) {
        if (src.hasMemoryAddress()) {
            PlatformDependent.copyMemory(src.memoryAddress() + srcIndex, addr(index), length);
        } else if (src.hasArray()) {
            PlatformDependent.copyMemory(src.array(), src.arrayOffset() + srcIndex, addr(index), length);
        } else {
            src.getBytes(srcIndex, this, index, length);
        }
    }
    return this;
}
 

@Override
protected void memoryCopy(ByteBuffer src, int srcOffset, ByteBuffer dst, int dstOffset, int length) {
    if (length == 0) {
        return;
    }

    if (HAS_UNSAFE) {
        PlatformDependent.copyMemory(
                PlatformDependent.directBufferAddress(src) + srcOffset,
                PlatformDependent.directBufferAddress(dst) + dstOffset, length);
    } else {
        // We must duplicate the NIO buffers because they may be accessed by other Netty buffers.我们必须复制NIO缓冲区，因为它们可能被其他Netty缓冲区访问。
        src = src.duplicate();
        dst = dst.duplicate();
        src.position(srcOffset).limit(srcOffset + length);
        dst.position(dstOffset);
        dst.put(src);
    }
}
 

@Override
public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
    checkIndex(index, length);
    if (dst == null) {
        throw new NullPointerException("dst");
    }
    if (dstIndex < 0 || dstIndex > dst.capacity() - length) {
        throw new IndexOutOfBoundsException("dstIndex: " + dstIndex);
    }

    if (dst.hasMemoryAddress()) {
        PlatformDependent.copyMemory(addr(index), dst.memoryAddress() + dstIndex, length);
    } else if (dst.hasArray()) {
        PlatformDependent.copyMemory(addr(index), dst.array(), dst.arrayOffset() + dstIndex, length);
    } else {
        dst.setBytes(dstIndex, this, index, length);
    }
    return this;
}
 

@Override
public int setBytes(int index, InputStream in, int length) throws IOException {
    checkIndex(index, length);
    byte[] tmp = new byte[length];
    int readBytes = in.read(tmp);
    if (readBytes > 0) {
        PlatformDependent.copyMemory(tmp, 0, addr(index), readBytes);
    }
    return readBytes;
}
 

@Override
public ByteBuf getBytes(int index, byte[] dst, int dstIndex, int length) {
    checkIndex(index, length);
    if (dst == null) {
        throw new NullPointerException("dst");
    }
    if (dstIndex < 0 || dstIndex > dst.length - length) {
        throw new IndexOutOfBoundsException("dstIndex: " + dstIndex);
    }
    if (length != 0) {
        PlatformDependent.copyMemory(addr(index), dst, dstIndex, length);
    }
    return this;
}
 

@Override
public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
    checkDstIndex(index, length, dstIndex, dst.capacity());
    if (dst.hasMemoryAddress()) {
        PlatformDependent.copyMemory(array, index, dst.memoryAddress() + dstIndex, length);
    } else if (dst.hasArray()) {
        getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length);
    } else {
        dst.setBytes(dstIndex, array, index, length);
    }
    return this;
}
 

@Override
public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
    checkDstIndex(index, length, dstIndex, dst.capacity());
    if (dst.hasMemoryAddress()) {
        PlatformDependent.copyMemory(memory, idx(index), dst.memoryAddress() + dstIndex, length);
    } else if (dst.hasArray()) {
        getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length);
    } else {
        dst.setBytes(dstIndex, memory, idx(index), length);
    }
    return this;
}
 

static void getBytes(AbstractByteBuf buf, long addr, int index, ByteBuf dst, int dstIndex, int length) {
    buf.checkIndex(index, length);
    checkNotNull(dst, "dst");
    if (isOutOfBounds(dstIndex, length, dst.capacity())) {
        throw new IndexOutOfBoundsException("dstIndex: " + dstIndex);
    }

    if (dst.hasMemoryAddress()) {
        PlatformDependent.copyMemory(addr, dst.memoryAddress() + dstIndex, length);
    } else if (dst.hasArray()) {
        PlatformDependent.copyMemory(addr, dst.array(), dst.arrayOffset() + dstIndex, length);
    } else {
        dst.setBytes(dstIndex, buf, index, length);
    }
}
 

static int setBytes(AbstractByteBuf buf, long addr, int index, InputStream in, int length) throws IOException {
    buf.checkIndex(index, length);
    ByteBuf tmpBuf = buf.alloc().heapBuffer(length);
    try {
        byte[] tmp = tmpBuf.array();
        int offset = tmpBuf.arrayOffset();
        int readBytes = in.read(tmp, offset, length);
        if (readBytes > 0) {
            PlatformDependent.copyMemory(tmp, offset, addr, readBytes);
        }
        return readBytes;
    } finally {
        tmpBuf.release();
    }
}
 

@Override
public byte[] getBytes(int fieldId) {
  long pos = getFieldAddr(fieldId);
  int len = PlatformDependent.getInt(pos);
  pos += SizeOf.SIZE_OF_INT;

  byte [] bytes = new byte[len];
  PlatformDependent.copyMemory(pos, bytes, 0, len);
  return bytes;
}
 

public void traceOrdinals(final long indexes, final int numRecords) {
  if (traceBuf == null) {
    return;
  }
  PlatformDependent.copyMemory(indexes, traceBufNext, 4 * numRecords);
  traceBufNext += 4 * numRecords;
}
 

public HeapTuple toHeapTuple() {
  HeapTuple heapTuple = new HeapTuple();
  byte [] bytes = new byte[getLength()];
  PlatformDependent.copyMemory(address(), bytes, 0, getLength());
  heapTuple.set(bytes, types);
  return heapTuple;
}
 

@Override
public final ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) {
    checkSrcIndex(index, length, srcIndex, src.capacity());
    if (src.hasMemoryAddress()) {
        PlatformDependent.copyMemory(src.memoryAddress() + srcIndex, memory, idx(index), length);
    } else if (src.hasArray()) {
        setBytes(index, src.array(), src.arrayOffset() + srcIndex, length);
    } else {
        src.getBytes(srcIndex, memory, idx(index), length);
    }
    return this;
}
 

@Override
public final ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) {
    checkDstIndex(index, length, dstIndex, dst.capacity());
    if (dst.hasMemoryAddress()) {
        PlatformDependent.copyMemory(memory, idx(index), dst.memoryAddress() + dstIndex, length);
    } else if (dst.hasArray()) {
        getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length);
    } else {
        dst.setBytes(dstIndex, memory, idx(index), length);
    }
    return this;
}
 

@Override
public ByteBuf getBytes(int index, OutputStream out, int length) throws IOException {
  wrapped.checkIndex(index, length);
  if (length != 0) {
    byte[] tmp = new byte[length];
    PlatformDependent.copyMemory(addr(index), tmp, 0, length);
    out.write(tmp);
  }
  return this;
}
 

@Override
public int setBytes(int index, InputStream in, int length) throws IOException {
  wrapped.checkIndex(index, length);
  byte[] tmp = new byte[length];
  int readBytes = in.read(tmp);
  if (readBytes > 0) {
    PlatformDependent.copyMemory(tmp, 0, addr(index), readBytes);
  }
  return readBytes;
}
 

@Override
public int setBytes(int index, InputStream in, int length) throws IOException {
    checkIndex(index, length);
    byte[] tmp = new byte[length];
    int readBytes = in.read(tmp);
    if (readBytes > 0) {
        PlatformDependent.copyMemory(tmp, 0, addr(index), readBytes);
    }
    return readBytes;
}
 

private void resizeBuffer(int sizeInBytes) {
  int targetSize = Numbers.nextPowerOfTwo(sizeInBytes);
  final ArrowBuf oldBuf = buf;
  buf = allocator.buffer(targetSize);
  PlatformDependent.copyMemory(oldBuf.memoryAddress(), buf.memoryAddress(), oldBuf.capacity());
  buf.writerIndex(oldBuf.writerIndex());
  oldBuf.release();
}
 

public static void unsafeCopy1MB(final long src, final long dst, int len) {
  PlatformDependent.copyMemory(src, dst, len);
}