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 NativeMemoryIO implements MemoryIODirectMemoryIO {
     protected static final com.kenai.jffi.MemoryIO IO = com.kenai.jffi.MemoryIO.getInstance();
     final NativeMemoryIO parent// keep a reference to avoid the memory being freed
     final long address;
     private final Ruby runtime;
 
     static final DirectMemoryIO wrap(Ruby runtimelong address) {
         return address != 0
                 ? new NativeMemoryIO(runtimeaddress)
                 : runtime.getFFI().getNullMemoryIO();
     }
 
     NativeMemoryIO(Ruby runtimelong address) {
         this. = runtime;
         this. = address;
         this. = null;
     }
     private NativeMemoryIO(NativeMemoryIO parentlong offset) {
         this. = parent;
         this. = parent.address + offset;
         this. = parent.runtime;
     }
 
     public final long getAddress() {
         return ;
     }
 
     public NativeMemoryIO slice(long offset) {
         return offset == 0 ? this :new NativeMemoryIO(thisoffset);
     }
 
     public DirectMemoryIO slice(long offsetlong size) {
         return new BoundedNativeMemoryIO(thisoffsetsize);
     }
     
     public MemoryIO dup() {
         throw .newNotImplementedError("cannot duplicate unbounded memory area");
     }
 
     public final java.nio.ByteBuffer asByteBuffer() {
         return .newDirectByteBuffer(.);
     }
 
     @Override
     public final boolean equals(Object obj) {
         return (obj instanceof DirectMemoryIO) && ((DirectMemoryIOobj).getAddress() == ;
     }
 
     @Override
     public final int hashCode() {
         int hash = 5;
         hash = 53 * hash + (int) (this. ^ (this. >>> 32));
         return hash;
     }
     
     public final boolean isNull() {
         return  == 0;
     }
     
     public final boolean isDirect() {
         return true;
     }
 
     public final ByteOrder order() {
         return ByteOrder.nativeOrder();
     }
 
     public final byte getByte(long offset) {
         return .getByte( + offset);
     }
 
     public final short getShort(long offset) {
         return .getShort( + offset);
     }
 
     public final int getInt(long offset) {
         return .getInt( + offset);
     }
 
     public final long getLong(long offset) {
         return .getLong( + offset);
     }
 
     public final long getNativeLong(long offset) {
         return Platform.getPlatform().longSize() == 32
                 ? .getInt( + offset)
                 : .getLong( + offset);
     }
 
    public final float getFloat(long offset) {
        return .getFloat( + offset);
    }
    public final double getDouble(long offset) {
        return .getDouble( + offset);
    }
    public final long getAddress(long offset) {
        return .getAddress( + offset);
    }
    public final DirectMemoryIO getMemoryIO(long offset) {
        return wrap(.getAddress( + offset));
    }
    public final void putByte(long offsetbyte value) {
        .putByte( + offsetvalue);
    }
    public final void putShort(long offsetshort value) {
        .putShort( + offsetvalue);
    }
    public final void putInt(long offsetint value) {
        .putInt( + offsetvalue);
    }
    public final void putLong(long offsetlong value) {
        .putLong( + offsetvalue);
    }
    public final void putNativeLong(long offsetlong value) {
        if (Platform.getPlatform().longSize() == 32) {
            .putInt( + offset, (intvalue);
        } else {
            .putLong( + offsetvalue);
        }
    }
    public final void putAddress(long offsetlong value) {
        .putAddress( + offsetvalue);
    }
    public final void putFloat(long offsetfloat value) {
        .putFloat( + offsetvalue);
    }
    public final void putDouble(long offsetdouble value) {
        .putDouble( + offsetvalue);
    }
    public final void putMemoryIO(long offsetMemoryIO value) {
        .putAddress( + offset, ((DirectMemoryIOvalue).getAddress());
    }
    public final void get(long offsetbyte[] dstint offint len) {
        .getByteArray( + offsetdstofflen);
    }
    public final void put(long offsetbyte[] srcint offint len) {
        .putByteArray( + offsetsrcofflen);
    }
    public final void get(long offsetshort[] dstint offint len) {
        .getShortArray( + offsetdstofflen);
    }
    public final void put(long offsetshort[] srcint offint len) {
        .putShortArray( + offsetsrcofflen);
    }
    public final void get(long offsetint[] dstint offint len) {
        .getIntArray( + offsetdstofflen);
    }
    public final void put(long offsetint[] srcint offint len) {
        .putIntArray( + offsetsrcofflen);
    }
    public final void get(long offsetlong[] dstint offint len) {
        .getLongArray( + offsetdstofflen);
    }
    public final void put(long offsetlong[] srcint offint len) {
        .putLongArray( + offsetsrcofflen);
    }
    public final void get(long offsetfloat[] dstint offint len) {
        .getFloatArray( + offsetdstofflen);
    }
    public final void put(long offsetfloat[] srcint offint len) {
        .putFloatArray( + offsetsrcofflen);
    }
    public final void get(long offsetdouble[] dstint offint len) {
        .getDoubleArray( + offsetdstofflen);
    }
    public final void put(long offsetdouble[] srcint offint len) {
        .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) {
        .setMemory( + offsetsizevalue);
    }
    public final byte[] getZeroTerminatedByteArray(long offset) {
        return .getZeroTerminatedByteArray( + offset);
    }
    public final byte[] getZeroTerminatedByteArray(long offsetint maxlen) {
        return .getZeroTerminatedByteArray( + offsetmaxlen);
    }
    public void putZeroTerminatedByteArray(long offsetbyte[] bytesint offint len) {
        .putZeroTerminatedByteArray( + offsetbytesofflen);
    }
New to GrepCode? Check out our FAQ X