BoundedNativeMemoryIO.java

  1. package org.jruby.ext.ffi.jffi;

  3. import java.nio.ByteOrder;
  4. import org.jruby.Ruby;
  5. import org.jruby.ext.ffi.*;

  7. class BoundedNativeMemoryIO extends MemoryIO {
  8.     protected static final com.kenai.jffi.MemoryIO IO = com.kenai.jffi.MemoryIO.getInstance();
  9.     protected static final int LONG_SIZE = Platform.getPlatform().longSize();
  10.     protected static final int ADDRESS_SIZE = Platform.getPlatform().addressSize();

  12.     private final Ruby runtime;
  13.     final long size;
  14.     final MemoryIO parent; // keep a reference to avoid the memory being freed

  16.     BoundedNativeMemoryIO(Ruby runtime, long address, int size) {
  17.         super(true, address);
  18.         this.runtime = runtime;
  19.         this.size = size;
  20.         this.parent = null;
  21.     }

  23.     BoundedNativeMemoryIO(BoundedNativeMemoryIO parent, long offset) {
  24.         super(true, parent.address() + offset);
  25.         this.runtime = parent.runtime;
  26.         this.size = parent.size - offset;
  27.         this.parent = parent;
  28.     }

  30.     BoundedNativeMemoryIO(Ruby runtime, MemoryIO parent, long offset, long size) {
  31.         super(true, parent.address() + offset);
  32.         this.runtime = runtime;
  33.         this.size = size;
  34.         this.parent = parent;
  35.         if (!parent.isDirect()) throw new IllegalArgumentException("non-direct memory");
  36.     }

  38.     private final void checkBounds(long off, long len) {
  39.         Util.checkBounds(runtime, size, off, len);
  40.     }

  42.     public Object array() {
  43.         throw runtime.newRuntimeError("no array");
  44.     }

  46.     public int arrayOffset() {
  47.         throw runtime.newRuntimeError("no array");
  48.     }

  50.     public int arrayLength() {
  51.         throw runtime.newRuntimeError("no array");
  52.     }

  54.     public BoundedNativeMemoryIO slice(long offset) {
  55.         checkBounds(offset, 0);
  56.         return offset == 0 ? this :new BoundedNativeMemoryIO(this, offset);
  57.     }

  59.     public BoundedNativeMemoryIO slice(long offset, long size) {
  60.         checkBounds(offset, size);
  61.         return offset == 0 && size == this.size ? this :new BoundedNativeMemoryIO(runtime, this, offset, size);
  62.     }
  63.     
  64.     public MemoryIO dup() {
  65.         AllocatedNativeMemoryIO tmp = AllocatedNativeMemoryIO.allocate(runtime, (int) size, false);
  66.         
  67.         IO.memcpy(tmp.address, address, size);
  68.         
  69.         return tmp;
  70.     }

  72.     public final java.nio.ByteBuffer asByteBuffer() {
  73.         return IO.newDirectByteBuffer(address, (int) size);
  74.     }

  76.     Ruby getRuntime() {
  77.         return this.runtime;
  78.     }

  80.     @Override
  81.     public final boolean equals(Object obj) {
  82.         return (obj instanceof MemoryIO) && ((MemoryIO) obj).address() == address;
  83.     }

  85.     @Override
  86.     public final int hashCode() {
  87.         int hash = 5;
  88.         hash = 53 * hash + (int) (this.address ^ (this.address >>> 32));
  89.         return hash;
  90.     }

  92.     public final ByteOrder order() {
  93.         return ByteOrder.nativeOrder();
  94.     }

  96.     public final byte getByte(long offset) {
  97.         checkBounds(offset, 1);
  98.         return IO.getByte(address + offset);
  99.     }

  101.     public final short getShort(long offset) {
  102.         checkBounds(offset, 2);
  103.         return IO.getShort(address + offset);
  104.     }

  106.     public final int getInt(long offset) {
  107.         checkBounds(offset, 4);
  108.         return IO.getInt(address + offset);
  109.     }

  111.     public final long getLong(long offset) {
  112.         checkBounds(offset, 8);
  113.         return IO.getLong(address + offset);
  114.     }

  116.     public final long getNativeLong(long offset) {
  117.         return LONG_SIZE == 32 ? getInt(offset) : getLong(offset);
  118.     }

  120.     public final float getFloat(long offset) {
  121.         checkBounds(offset, 4);
  122.         return IO.getFloat(address + offset);
  123.     }

  125.     public final double getDouble(long offset) {
  126.         checkBounds(offset, 8);
  127.         return IO.getDouble(address + offset);
  128.     }

  130.     public final long getAddress(long offset) {
  131.         checkBounds(offset, ADDRESS_SIZE >> 3);
  132.         return IO.getAddress(address + offset);
  133.     }

  135.     public final MemoryIO getMemoryIO(long offset) {
  136.         checkBounds(offset, ADDRESS_SIZE >> 3);
  137.         return NativeMemoryIO.wrap(runtime, IO.getAddress(address + offset));
  138.     }

  140.     public final void putByte(long offset, byte value) {
  141.         checkBounds(offset, 1);
  142.         IO.putByte(address + offset, value);
  143.     }

  145.     public final void putShort(long offset, short value) {
  146.         checkBounds(offset, 2);
  147.         IO.putShort(address + offset, value);
  148.     }

  150.     public final void putInt(long offset, int value) {
  151.         checkBounds(offset, 4);
  152.         IO.putInt(address + offset, value);
  153.     }

  155.     public final void putLong(long offset, long value) {
  156.         checkBounds(offset, 8);
  157.         IO.putLong(address + offset, value);
  158.     }

  160.     public final void putNativeLong(long offset, long value) {
  161.         if (LONG_SIZE == 32) {
  162.             putInt(offset, (int) value);
  163.         } else {
  164.             putLong(offset, value);
  165.         }
  166.     }
  167.     public final void putAddress(long offset, long value) {
  168.         checkBounds(offset, ADDRESS_SIZE >> 3);
  169.         IO.putAddress(address + offset, value);
  170.     }
  171.     public final void putFloat(long offset, float value) {
  172.         checkBounds(offset, 4);
  173.         IO.putFloat(address + offset, value);
  174.     }

  176.     public final void putDouble(long offset, double value) {
  177.         checkBounds(offset, 8);
  178.         IO.putDouble(address + offset, value);
  179.     }

  181.     public final void putMemoryIO(long offset, MemoryIO value) {
  182.         checkBounds(offset, ADDRESS_SIZE >> 3);
  183.         IO.putAddress(address + offset, value.address());
  184.     }

  186.     public final void get(long offset, byte[] dst, int off, int len) {
  187.         checkBounds(offset, len);
  188.         IO.getByteArray(address + offset, dst, off, len);
  189.     }

  191.     public final void put(long offset, byte[] src, int off, int len) {
  192.         checkBounds(offset, len);
  193.         IO.putByteArray(address + offset, src, off, len);
  194.     }

  196.     public final void get(long offset, short[] dst, int off, int len) {
  197.         checkBounds(offset, len << 1);
  198.         IO.getShortArray(address + offset, dst, off, len);
  199.     }

  201.     public final void put(long offset, short[] src, int off, int len) {
  202.         checkBounds(offset, len << 1);
  203.         IO.putShortArray(address + offset, src, off, len);
  204.     }

  206.     public final void get(long offset, int[] dst, int off, int len) {
  207.         checkBounds(offset, len << 2);
  208.         IO.getIntArray(address + offset, dst, off, len);
  209.     }

  211.     public final void put(long offset, int[] src, int off, int len) {
  212.         checkBounds(offset, len << 2);
  213.         IO.putIntArray(address + offset, src, off, len);
  214.     }

  216.     public final void get(long offset, long[] dst, int off, int len) {
  217.         checkBounds(offset, len << 3);
  218.         IO.getLongArray(address + offset, dst, off, len);
  219.     }

  221.     public final void put(long offset, long[] src, int off, int len) {
  222.         checkBounds(offset, len << 3);
  223.         IO.putLongArray(address + offset, src, off, len);
  224.     }

  226.     public final void get(long offset, float[] dst, int off, int len) {
  227.         checkBounds(offset, len << 2);
  228.         IO.getFloatArray(address + offset, dst, off, len);
  229.     }

  231.     public final void put(long offset, float[] src, int off, int len) {
  232.         checkBounds(offset, len << 2);
  233.         IO.putFloatArray(address + offset, src, off, len);
  234.     }

  236.     public final void get(long offset, double[] dst, int off, int len) {
  237.         checkBounds(offset, len << 3);
  238.         IO.getDoubleArray(address + offset, dst, off, len);
  239.     }

  241.     public final void put(long offset, double[] src, int off, int len) {
  242.         checkBounds(offset, len << 3);
  243.         IO.putDoubleArray(address + offset, src, off, len);
  244.     }

  246.     public final int indexOf(long offset, byte value) {
  247.         return value == 0
  248.                 ? (int) IO.getStringLength(address + offset)
  249.                 : (int) IO.indexOf(address + offset, value);
  250.     }

  252.     public final int indexOf(long offset, byte value, int maxlen) {
  253.         return (int) IO.indexOf(address, value, maxlen);
  254.     }

  256.     public final void setMemory(long offset, long size, byte value) {
  257.         checkBounds(offset, size);
  258.         IO.setMemory(address + offset, size, value);
  259.     }

  261.     public final byte[] getZeroTerminatedByteArray(long offset) {
  262.         checkBounds(offset, 1);
  263.         return IO.getZeroTerminatedByteArray(address + offset);
  264.     }

  266.     public final byte[] getZeroTerminatedByteArray(long offset, int maxlen) {
  267.         checkBounds(offset, 1);
  268.         return IO.getZeroTerminatedByteArray(address + offset,
  269.                 Math.min(maxlen, (int) (size - offset)));
  270.     }

  272.     public void putZeroTerminatedByteArray(long offset, byte[] bytes, int off, int len) {
  273.         // Ensure room for terminating zero byte
  274.         checkBounds(offset, len + 1);
  275.         IO.putZeroTerminatedByteArray(address + offset, bytes, off, len);
  276.     }

  278. }
Created with JaCoCo 0.7.3.201501050207