Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi;
  
  import java.nio.ByteOrder;
  import java.util.Arrays;
  import org.jruby.Ruby;
  
  public final class ArrayMemoryIO implements MemoryIO {
  
     protected static final ArrayIO IO = getArrayIO();
     protected static final int LONG_SIZE = Platform.getPlatform().longSize();
     protected static final int ADDRESS_SIZE = Platform.getPlatform().addressSize();
 
     protected final Ruby runtime;
     protected final byte[] buffer;
     protected final int offsetlength;
 
     public ArrayMemoryIO(Ruby runtimebyte[] bufferint offsetint length) {
         this. = runtime;
         this. = buffer;
         this. = offset;
         this. = length;
     }
     
     public ArrayMemoryIO(Ruby runtimeint size) {
         this(runtimenew byte[size], 0, size);
     }
     
     private final void checkBounds(long offlong len) {
         Util.checkBounds(arrayLength(), offlen);
     }
     
     public final byte[] array() {
         return ;
     }
     public final int arrayOffset() {
         return ;
     }
     public final int arrayLength() {
         return ;
     }
     private static final ArrayIO getArrayIO() {
         if (ByteOrder.nativeOrder().equals(.)) {
             return Platform.getPlatform().addressSize() == 64
                     ? newBE64ArrayIO() : newBE32ArrayIO();
         } else {
             return Platform.getPlatform().addressSize() == 64
                     ? newLE64ArrayIO() : newLE32ArrayIO();
         }
     }
     private static final ArrayIO newBE64ArrayIO() {
         return new BE64ArrayIO();
     }
     private static final ArrayIO newBE32ArrayIO() {
         return new BE32ArrayIO();
     }
     private static final ArrayIO newLE64ArrayIO() {
         return new LE64ArrayIO();
     }
     private static final ArrayIO newLE32ArrayIO() {
         return new LE32ArrayIO();
     }
     protected final int index(long off) {
         return this. + (intoff;
     }
     public final boolean isNull() {
         return false;
     }
     public final boolean isDirect() {
         return false;
     }
 
     public final ByteOrder order() {
         return ByteOrder.nativeOrder();
     }
 
     public ArrayMemoryIO slice(long offset) {
         checkBounds(offset, 1);
         return offset == 0 ? this : new ArrayMemoryIO(array(), arrayOffset() + (intoffsetarrayLength() - (intoffset);
     }
 
     public ArrayMemoryIO slice(long offsetlong size) {
         checkBounds(offsetsize);
 
         return offset == 0 && size == this.
                 ? this
                 : new ArrayMemoryIO(array(), arrayOffset() + (intoffset, (intsize);
     }
 
     public ArrayMemoryIO dup() {
         ArrayMemoryIO tmp = new ArrayMemoryIO();
         System.arraycopy(array(), arrayOffset(), tmp.array(), tmp.arrayOffset(), );
         
         return tmp;
     }
     
     
     
     public java.nio.ByteBuffer asByteBuffer() {
        return java.nio.ByteBuffer.wrap().duplicate();
    }
    public final DirectMemoryIO getMemoryIO(long offset) {
        checkBounds(offset >> 3);
        return Factory.getInstance().wrapDirectMemory(getAddress(offset));
    }
    public final void putMemoryIO(long offsetMemoryIO value) {
        checkBounds(offset >> 3);
        putAddress(offset, ((DirectMemoryIOvalue).getAddress());
    }
    public final byte getByte(long offset) {
        checkBounds(offset, 1);
        return (byte) ([index(offset)] & 0xff);
    }
    public final short getShort(long offset) {
        checkBounds(offset, 2);
        return .getInt16(index(offset));
    }
    public final int getInt(long offset) {
        checkBounds(offset, 4);
        return .getInt32(index(offset));
    }
    public final long getLong(long offset) {
        checkBounds(offset, 8);
        return .getInt64(index(offset));
    }
    public final long getNativeLong(long offset) {
        return  == 32 ? getInt(offset) : getLong(offset);
    }
    public final float getFloat(long offset) {
        checkBounds(offset, 4);
        return .getFloat32(index(offset));
    }
    public final double getDouble(long offset) {
        checkBounds(offset, 8);
        return .getFloat64(index(offset));
    }
    public final long getAddress(long offset) {
        checkBounds(offset >> 3);
        return .getAddress(index(offset));
    }
    public final void putByte(long offsetbyte value) {
        checkBounds(offset, 1);
        [index(offset)] = value;
    }
    public final void putShort(long offsetshort value) {
        checkBounds(offset, 2);
        .putInt16(index(offset), value);
    }
    public final void putInt(long offsetint value) {
        checkBounds(offset, 4);
        .putInt32(index(offset), value);
    }
    public final void putLong(long offsetlong value) {
        checkBounds(offset, 8);
        .putInt64(index(offset), value);
    }
    public final void putNativeLong(long offsetlong value) {
        if ( == 32) {
            putInt(offset, (intvalue);
        } else {
            putLong(offsetvalue);
        }
    }
    public final void putFloat(long offsetfloat value) {
        checkBounds(offset, 4);
        .putFloat32(index(offset), value);
    }
    public final void putDouble(long offsetdouble value) {
        checkBounds(offset, 8);
        .putFloat64(index(offset), value);
    }
    public final void putAddress(long offsetlong value) {
        checkBounds(offset >> 3);
        .putAddress(index(offset), value);
    }
    public final void get(long offsetbyte[] dstint offint len) {
        checkBounds(offsetlen);
        System.arraycopy(index(offset), dstofflen);
    }
    public final void put(long offsetbyte[] srcint offint len) {
        checkBounds(offsetlen);
        System.arraycopy(srcoffindex(offset), len);
    }
    public final void get(long offsetshort[] dstint offint len) {
        checkBounds(offsetlen << 1);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = .getInt16(begin + (i << 1));
        }
    }
    public final void put(long offsetshort[] srcint offint len) {
        checkBounds(offsetlen << 1);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            .putInt16(begin + (i << 1), src[off + i]);
        }
    }
    public final void get(long offsetint[] dstint offint len) {
        checkBounds(offsetlen << 2);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = .getInt32(begin + (i << 2));
        }
    }
    public final void put(long offsetint[] srcint offint len) {
        checkBounds(offsetlen << 2);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            .putInt32(begin + (i << 2), src[off + i]);
        }
    }
    public final void get(long offsetlong[] dstint offint len) {
        checkBounds(offsetlen << 3);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = .getInt64(begin + (i << 3));
        }
    }
    public final void put(long offsetlong[] srcint offint len) {
        checkBounds(offsetlen << 3);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            .putInt64(begin + (i << 3), src[off + i]);
        }
    }
    public final void get(long offsetfloat[] dstint offint len) {
        checkBounds(offsetlen << 2);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = .getFloat32(begin + (i << 2));
        }
    }
    public final void put(long offsetfloat[] srcint offint len) {
        checkBounds(offsetlen << 2);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            .putFloat32(begin + (i << 2), src[off + i]);
        }
    }
    public final void get(long offsetdouble[] dstint offint len) {
        checkBounds(offsetlen << 3);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = .getFloat64(begin + (i << 3));
        }
    }
    public final void put(long offsetdouble[] srcint offint len) {
        checkBounds(offsetlen << 3);
        int begin = index(offset);
        for (int i = 0; i < len; ++i) {
            .putFloat64(begin + (i << 3), src[off + i]);
        }
    }
    public final int indexOf(long offsetbyte value) {
        int off = index(offset);
        for (int i = 0; i < ; ++i) {
            if ([off + i] == value) {
                return i;
            }
        }
        return -1;
    }
    public final int indexOf(long offsetbyte valueint maxlen) {
        int off = index(offset);
        for (int i = 0; i < Math.min(maxlen); ++i) {
            if ([off + i] == value) {
                return i;
            }
        }
        return -1;
    }
    public final void setMemory(long offsetlong sizebyte value) {
        checkBounds(offsetsize);
        Arrays.fill(index(offset), (intsizevalue);
    }
    public final byte[] getZeroTerminatedByteArray(long offset) {
        checkBounds(offset, 1);
        int len = indexOf(offset, (byte) 0);
        byte[] bytes = new byte[len != -1 ? len :  - (intoffset];
        System.arraycopy(index(offset), bytes, 0, bytes.length);
        return bytes;
    }
    public final byte[] getZeroTerminatedByteArray(long offsetint maxlen) {
        checkBounds(offset, 1);
        int len = indexOf(offset, (byte) 0, maxlen);
        byte[] bytes = new byte[len != -1 ? len : Math.min( - (intoffsetmaxlen)];
        System.arraycopy(index(offset), bytes, 0, bytes.length);
        return bytes;
    }
    public void putZeroTerminatedByteArray(long offsetbyte[] bytesint offint len) {
        // Ensure room for terminating zero byte
        checkBounds(offsetlen + 1);
        System.arraycopy(bytesoffindex(offset), len);
        [len] = (byte) 0;
    }
    public final void clear() {
        Arrays.fill(, (byte) 0);
    }
    protected static abstract class ArrayIO {
        
        public abstract short getInt16(byte[] bufferint offset);
        public abstract int getInt32(byte[] bufferint offset);
        public abstract long getInt64(byte[] bufferint offset);
        public abstract long getAddress(byte[] bufferint offset);
        
        public abstract void putInt16(byte[] bufferint offsetint value);
        public abstract void putInt32(byte[] bufferint offsetint value);
        public abstract void putInt64(byte[] bufferint offsetlong value);
        public abstract void putAddress(byte[] bufferint offsetlong value);
        public final float getFloat32(byte[] bufferint offset) {
            return Float.intBitsToFloat(getInt32(bufferoffset));
        }
        public final void putFloat32(byte[] bufferint offsetfloat value) {
            putInt32(bufferoffset, Float.floatToRawIntBits(value));
        }
        public final double getFloat64(byte[] bufferint offset) {
            return Double.longBitsToDouble(getInt64(bufferoffset));
        }
        public final void putFloat64(byte[] bufferint offsetdouble value) {
            putInt64(bufferoffset, Double.doubleToRawLongBits(value));
        }
    }
    private static abstract class LittleEndianArrayIO extends ArrayIO {
        public final short getInt16(byte[] arrayint offset) {
            return (short) ((array[offset] & 0xff) | ((array[offset + 1] & 0xff) << 8));
        }
        public final int getInt32(byte[] arrayint offset) {
            return    ((array[offset + 0] & 0xff) << 0)
                    | ((array[offset + 1] & 0xff) << 8)
                    | ((array[offset + 2] & 0xff) << 16)
                    | ((array[offset + 3] & 0xff) << 24);
        }
        public final long getInt64(byte[] arrayint offset) {
            return    (((long)array[offset + 0] & 0xff) << 0)
                    | (((long)array[offset + 1] & 0xff) << 8)
                    | (((long)array[offset + 2] & 0xff) << 16)
                    | (((long)array[offset + 3] & 0xff) << 24)
                    | (((long)array[offset + 4] & 0xff) << 32)
                    | (((long)array[offset + 5] & 0xff) << 40)
                    | (((long)array[offset + 6] & 0xff) << 48)
                    | (((long)array[offset + 7] & 0xff) << 56);
        }
        public final void putInt16(byte[] bufferint offsetint value) {
            buffer[offset + 0] = (byte) (value >> 0);
            buffer[offset + 1] = (byte) (value >> 8);
        }
        public final void putInt32(byte[] bufferint offsetint value) {
            buffer[offset + 0] = (byte) (value >> 0);
            buffer[offset + 1] = (byte) (value >> 8);
            buffer[offset + 2] = (byte) (value >> 16);
            buffer[offset + 3] = (byte) (value >> 24);
        }
        public final void putInt64(byte[] bufferint offsetlong value) {
            buffer[offset + 0] = (byte) (value >> 0);
            buffer[offset + 1] = (byte) (value >> 8);
            buffer[offset + 2] = (byte) (value >> 16);
            buffer[offset + 3] = (byte) (value >> 24);
            buffer[offset + 4] = (byte) (value >> 32);
            buffer[offset + 5] = (byte) (value >> 40);
            buffer[offset + 6] = (byte) (value >> 48);
            buffer[offset + 7] = (byte) (value >> 56);
        }
    }
    private static abstract class BigEndianArrayIO extends ArrayIO {
        public short getInt16(byte[] arrayint offset) {
            return (short) (((array[offset + 0] & 0xff) << 8)
                    | (array[offset + 1] & 0xff));
        }
        public int getInt32(byte[] arrayint offset) {
            return    ((array[offset + 0] & 0xff) << 24)
                    | ((array[offset + 1] & 0xff) << 16)
                    | ((array[offset + 2] & 0xff) << 8)
                    | ((array[offset + 3] & 0xff) << 0);
        }
        public long getInt64(byte[] arrayint offset) {
            return    (((long)array[offset + 0] & 0xff) << 56)
                    | (((long)array[offset + 1] & 0xff) << 48)
                    | (((long)array[offset + 2] & 0xff) << 40)
                    | (((long)array[offset + 3] & 0xff) << 32)
                    | (((long)array[offset + 4] & 0xff) << 24)
                    | (((long)array[offset + 5] & 0xff) << 16)
                    | (((long)array[offset + 6] & 0xff) << 8)
                    | (((long)array[offset + 7] & 0xff) << 0);
        }
        public final void putInt16(byte[] bufferint offsetint value) {
            buffer[offset + 0] = (byte) (value >> 8);
            buffer[offset + 1] = (byte) (value >> 0);
        }
        public final void putInt32(byte[] bufferint offsetint value) {
            buffer[offset + 0] = (byte) (value >> 24);
            buffer[offset + 1] = (byte) (value >> 16);
            buffer[offset + 2] = (byte) (value >> 8);
            buffer[offset + 3] = (byte) (value >> 0);
        }
        public final void putInt64(byte[] bufferint offsetlong value) {
            buffer[offset + 0] = (byte) (value >> 56);
            buffer[offset + 1] = (byte) (value >> 48);
            buffer[offset + 2] = (byte) (value >> 40);
            buffer[offset + 3] = (byte) (value >> 32);
            buffer[offset + 4] = (byte) (value >> 24);
            buffer[offset + 5] = (byte) (value >> 16);
            buffer[offset + 6] = (byte) (value >> 8);
            buffer[offset + 7] = (byte) (value >> 0);
        }
    }
    private static final class LE32ArrayIO extends LittleEndianArrayIO {
        public final long getAddress(byte[] bufferint offset) {
            return ((longgetInt32(bufferoffset)) & 0xffffffffL;
        }
        public final void putAddress(byte[] bufferint offsetlong value) {
            putInt32(bufferoffset, (intvalue);
        }
    }
    private static final class LE64ArrayIO extends LittleEndianArrayIO {
        public final long getAddress(byte[] bufferint offset) {
            return getInt64(bufferoffset);
        }
        public final void putAddress(byte[] bufferint offsetlong value) {
            putInt64(bufferoffsetvalue);
        }
    }
    private static final class BE32ArrayIO extends BigEndianArrayIO {
        public final long getAddress(byte[] bufferint offset) {
            return ((longgetInt32(bufferoffset)) & 0xffffffffL;
        }
        public final void putAddress(byte[] bufferint offsetlong value) {
            putInt32(bufferoffset, (intvalue);
        }
    }
    private static final class BE64ArrayIO extends BigEndianArrayIO {
        public final long getAddress(byte[] bufferint offset) {
            return getInt64(bufferoffset);
        }
        public final void putAddress(byte[] bufferint offsetlong value) {
            putInt64(bufferoffsetvalue);
        }
    }
New to GrepCode? Check out our FAQ X