Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi.jffi;
  
  import java.nio.ByteOrder;
  import org.jruby.Ruby;
  
  class BoundedNativeMemoryIO extends MemoryIO {
      protected static final com.kenai.jffi.MemoryIO IO = com.kenai.jffi.MemoryIO.getInstance();
     protected static final int LONG_SIZE = Platform.getPlatform().longSize();
     protected static final int ADDRESS_SIZE = Platform.getPlatform().addressSize();
 
     private final Ruby runtime;
     final long size;
     final MemoryIO parent// keep a reference to avoid the memory being freed
 
     BoundedNativeMemoryIO(Ruby runtimelong addressint size) {
         super(trueaddress);
         this. = runtime;
         this. = size;
         this. = null;
     }
 
     BoundedNativeMemoryIO(BoundedNativeMemoryIO parentlong offset) {
         super(trueparent.address() + offset);
         this. = parent.runtime;
         this. = parent.size - offset;
         this. = parent;
     }
 
     BoundedNativeMemoryIO(Ruby runtimeMemoryIO parentlong offsetlong size) {
         super(trueparent.address() + offset);
         this. = runtime;
         this. = size;
         this. = parent;
         if (!parent.isDirect()) throw new IllegalArgumentException("non-direct memory");
     }
 
     private final void checkBounds(long offlong len) {
         Util.checkBounds(offlen);
     }
 
     public Object array() {
         throw .newRuntimeError("no array");
     }
 
     public int arrayOffset() {
         throw .newRuntimeError("no array");
     }
 
     public int arrayLength() {
         throw .newRuntimeError("no array");
     }
 
     public BoundedNativeMemoryIO slice(long offset) {
         checkBounds(offset, 0);
         return offset == 0 ? this :new BoundedNativeMemoryIO(thisoffset);
     }
 
     public BoundedNativeMemoryIO slice(long offsetlong size) {
         checkBounds(offsetsize);
         return offset == 0 && size == this. ? this :new BoundedNativeMemoryIO(thisoffsetsize);
     }
     
     public MemoryIO dup() {
         AllocatedNativeMemoryIO tmp = AllocatedNativeMemoryIO.allocate(, (intfalse);
         
         .memcpy(tmp.address);
         
         return tmp;
     }
 
     public final java.nio.ByteBuffer asByteBuffer() {
         return .newDirectByteBuffer(, (int);
     }
 
     Ruby getRuntime() {
         return this.;
     }
 
     @Override
     public final boolean equals(Object obj) {
         return (obj instanceof MemoryIO) && ((MemoryIOobj).address() == ;
     }
 
     @Override
     public final int hashCode() {
         int hash = 5;
         hash = 53 * hash + (int) (this. ^ (this. >>> 32));
         return hash;
     }
 
     public final ByteOrder order() {
         return ByteOrder.nativeOrder();
     }
 
     public final byte getByte(long offset) {
         checkBounds(offset, 1);
         return .getByte( + offset);
    }
    public final short getShort(long offset) {
        checkBounds(offset, 2);
        return .getShort( + offset);
    }
    public final int getInt(long offset) {
        checkBounds(offset, 4);
        return .getInt( + offset);
    }
    public final long getLong(long offset) {
        checkBounds(offset, 8);
        return .getLong( + offset);
    }
    public final long getNativeLong(long offset) {
        return  == 32 ? getInt(offset) : getLong(offset);
    }
    public final float getFloat(long offset) {
        checkBounds(offset, 4);
        return .getFloat( + offset);
    }
    public final double getDouble(long offset) {
        checkBounds(offset, 8);
        return .getDouble( + offset);
    }
    public final long getAddress(long offset) {
        checkBounds(offset >> 3);
        return .getAddress( + offset);
    }
    public final MemoryIO getMemoryIO(long offset) {
        checkBounds(offset >> 3);
        return NativeMemoryIO.wrap(.getAddress( + offset));
    }
    public final void putByte(long offsetbyte value) {
        checkBounds(offset, 1);
        .putByte( + offsetvalue);
    }
    public final void putShort(long offsetshort value) {
        checkBounds(offset, 2);
        .putShort( + offsetvalue);
    }
    public final void putInt(long offsetint value) {
        checkBounds(offset, 4);
        .putInt( + offsetvalue);
    }
    public final void putLong(long offsetlong value) {
        checkBounds(offset, 8);
        .putLong( + offsetvalue);
    }
    public final void putNativeLong(long offsetlong value) {
        if ( == 32) {
            putInt(offset, (intvalue);
        } else {
            putLong(offsetvalue);
        }
    }
    public final void putAddress(long offsetlong value) {
        checkBounds(offset >> 3);
        .putAddress( + offsetvalue);
    }
    public final void putFloat(long offsetfloat value) {
        checkBounds(offset, 4);
        .putFloat( + offsetvalue);
    }
    public final void putDouble(long offsetdouble value) {
        checkBounds(offset, 8);
        .putDouble( + offsetvalue);
    }
    public final void putMemoryIO(long offsetMemoryIO value) {
        checkBounds(offset >> 3);
        .putAddress( + offsetvalue.address());
    }
    public final void get(long offsetbyte[] dstint offint len) {
        checkBounds(offsetlen);
        .getByteArray( + offsetdstofflen);
    }
    public final void put(long offsetbyte[] srcint offint len) {
        checkBounds(offsetlen);
        .putByteArray( + offsetsrcofflen);
    }
    public final void get(long offsetshort[] dstint offint len) {
        checkBounds(offsetlen << 1);
        .getShortArray( + offsetdstofflen);
    }
    public final void put(long offsetshort[] srcint offint len) {
        checkBounds(offsetlen << 1);
        .putShortArray( + offsetsrcofflen);
    }
    public final void get(long offsetint[] dstint offint len) {
        checkBounds(offsetlen << 2);
        .getIntArray( + offsetdstofflen);
    }
    public final void put(long offsetint[] srcint offint len) {
        checkBounds(offsetlen << 2);
        .putIntArray( + offsetsrcofflen);
    }
    public final void get(long offsetlong[] dstint offint len) {
        checkBounds(offsetlen << 3);
        .getLongArray( + offsetdstofflen);
    }
    public final void put(long offsetlong[] srcint offint len) {
        checkBounds(offsetlen << 3);
        .putLongArray( + offsetsrcofflen);
    }
    public final void get(long offsetfloat[] dstint offint len) {
        checkBounds(offsetlen << 2);
        .getFloatArray( + offsetdstofflen);
    }
    public final void put(long offsetfloat[] srcint offint len) {
        checkBounds(offsetlen << 2);
        .putFloatArray( + offsetsrcofflen);
    }
    public final void get(long offsetdouble[] dstint offint len) {
        checkBounds(offsetlen << 3);
        .getDoubleArray( + offsetdstofflen);
    }
    public final void put(long offsetdouble[] srcint offint len) {
        checkBounds(offsetlen << 3);
        .putDoubleArray( + offsetsrcofflen);
    }
    public final int indexOf(long offsetbyte value) {
        return value == 0
                ? (int.getStringLength( + offset)
                : (int.indexOf( + offsetvalue);
    }
    public final int indexOf(long offsetbyte valueint maxlen) {
        return (int.indexOf(valuemaxlen);
    }
    public final void setMemory(long offsetlong sizebyte value) {
        checkBounds(offsetsize);
        .setMemory( + offsetsizevalue);
    }
    public final byte[] getZeroTerminatedByteArray(long offset) {
        checkBounds(offset, 1);
        return .getZeroTerminatedByteArray( + offset);
    }
    public final byte[] getZeroTerminatedByteArray(long offsetint maxlen) {
        checkBounds(offset, 1);
        return .getZeroTerminatedByteArray( + offset,
                Math.min(maxlen, (int) ( - offset)));
    }
    public void putZeroTerminatedByteArray(long offsetbyte[] bytesint offint len) {
        // Ensure room for terminating zero byte
        checkBounds(offsetlen + 1);
        .putZeroTerminatedByteArray( + offsetbytesofflen);
    }
New to GrepCode? Check out our FAQ X