Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * To change this template, choose Tools | Templates
   * and open the template in the editor.
   */
  
  package org.jruby.ext.ffi;
  
  import java.nio.ByteOrder;
  import org.jruby.Ruby;

 
 public final class SwappedMemoryIO implements MemoryIODirectMemoryIO {
     protected static final int LONG_SIZE = Platform.getPlatform().longSize();
     protected static final int ADDRESS_SIZE = Platform.getPlatform().addressSize();
 
     private final Ruby runtime;
     private final MemoryIO io;
 
     SwappedMemoryIO(Ruby runtimeMemoryIO io) {
         this. = runtime;
         this. = io;
     }
 
     public final ByteOrder order() {
         return ByteOrder.nativeOrder().equals(.)
                 ? . : .;
     }
 
     public final long getAddress() {
         return  instanceof DirectMemoryIO ? ((DirectMemoryIO).getAddress() : 0L;
     }
 
     public SwappedMemoryIO slice(long offset) {
         return offset == 0 ? this : new SwappedMemoryIO(.slice(offset));
     }
 
     public SwappedMemoryIO slice(long offsetlong size) {
         return new SwappedMemoryIO(.slice(offsetsize));
     }
     
     public SwappedMemoryIO dup() {
         return new SwappedMemoryIO(.dup());
     }
 
     public final java.nio.ByteBuffer asByteBuffer() {
         return .asByteBuffer().order(order());
     }
 
     Ruby getRuntime() {
         return this.;
     }
 
     @Override
     public final boolean equals(Object obj) {
         return obj == this || (obj instanceof SwappedMemoryIO) && ((SwappedMemoryIOobj)..equals();
     }
 
     @Override
     public final int hashCode() {
         return .hashCode();
     }
 
     public final boolean isNull() {
         return .isNull();
     }
 
     public final boolean isDirect() {
         return .isDirect();
     }
 
     public final byte getByte(long offset) {
         return .getByte(offset);
     }
 
     public final short getShort(long offset) {
         return Short.reverseBytes(.getShort(offset));
     }
 
     public final int getInt(long offset) {
         return Integer.reverseBytes(.getInt(offset));
     }
 
     public final long getLong(long offset) {
         return Long.reverseBytes(.getLong(offset));
     }
 
     public final long getNativeLong(long offset) {
         return  == 32 ? getInt(offset) : getLong(offset);
     }
 
     public final float getFloat(long offset) {
         return Float.intBitsToFloat(Integer.reverseBytes(Float.floatToRawIntBits(.getFloat(offset))));
     }
 
     public final double getDouble(long offset) {
         return Double.longBitsToDouble(Long.reverseBytes(Double.doubleToRawLongBits(.getDouble(offset))));
     }
    public final long getAddress(long offset) {
        throw .newRuntimeError("cannot get native address values in non-native byte order memory");
    }
    public final DirectMemoryIO getMemoryIO(long offset) {
        throw .newRuntimeError("cannot get native address values in non-native byte order memory");
    }
    public final void putByte(long offsetbyte value) {
        .putByte(offsetvalue);
    }
    public final void putShort(long offsetshort value) {
        .putShort(offset, Short.reverseBytes(value));
    }
    public final void putInt(long offsetint value) {
        .putInt(offset, Integer.reverseBytes(value));
    }
    public final void putLong(long offsetlong value) {
        .putLong(offset, Long.reverseBytes(value));
    }
    public final void putNativeLong(long offsetlong value) {
        if ( == 32) {
            putInt(offset, (intvalue);
        } else {
            putLong(offsetvalue);
        }
    }
    public final void putAddress(long offsetlong value) {
        throw .newRuntimeError("cannot write native address values to non-native byte order memory");
    }
    
    public final void putFloat(long offsetfloat value) {
        .putFloat(offset, Float.intBitsToFloat(Integer.reverseBytes(Float.floatToRawIntBits(value))));
    }
    public final void putDouble(long offsetdouble value) {
        .putDouble(offset, Double.longBitsToDouble(Long.reverseBytes(Double.doubleToRawLongBits(value))));
    }
    public final void putMemoryIO(long offsetMemoryIO value) {
        throw .newRuntimeError("cannot write native address values to non-native byte order memory");
    }
    public final void get(long offsetbyte[] dstint offint len) {
        .get(offsetdstofflen);
    }
    public final void put(long offsetbyte[] srcint offint len) {
        .put(offsetsrcofflen);
    }
    public final void get(long offsetshort[] dstint offint len) {
        .get(offsetdstofflen);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = Short.reverseBytes(dst[off + i]);
        }
    }
    public final void put(long offsetshort[] srcint offint len) {
        short[] values = new short[len];
        for (int i = 0; i < len; ++i) {
            values[i] = Short.reverseBytes(src[off + i]);
        }
        .put(offsetvalues, 0, len);
    }
    public final void get(long offsetint[] dstint offint len) {
        .get(offsetdstofflen);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = Integer.reverseBytes(dst[off + i]);
        }
    }
    public final void put(long offsetint[] srcint offint len) {
        int[] values = new int[len];
        for (int i = 0; i < len; ++i) {
            values[i] = Integer.reverseBytes(src[off + i]);
        }
        .put(offsetvalues, 0, len);
    }
    public final void get(long offsetlong[] dstint offint len) {
        .get(offsetdstofflen);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = Long.reverseBytes(dst[off + i]);
        }
    }
    public final void put(long offsetlong[] srcint offint len) {
        long[] values = new long[len];
        for (int i = 0; i < len; ++i) {
            values[i] = Long.reverseBytes(src[off + i]);
        }
        .put(offsetvalues, 0, len);
    }
    public final void get(long offsetfloat[] dstint offint len) {
        .get(offsetdstofflen);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = Float.intBitsToFloat(Integer.reverseBytes(Float.floatToRawIntBits(dst[off + i])));
        }
    }
    public final void put(long offsetfloat[] srcint offint len) {
        int[] values = new int[len];
        for (int i = 0; i < len; ++i) {
            values[i] = Integer.reverseBytes(Float.floatToRawIntBits(src[off + i]));
        }
        .put(offsetvalues, 0, len);
    }
    public final void get(long offsetdouble[] dstint offint len) {
        .get(offsetdstofflen);
        for (int i = 0; i < len; ++i) {
            dst[off + i] = Double.longBitsToDouble(Long.reverseBytes(Double.doubleToRawLongBits(dst[off + i])));
        }
    }
    public final void put(long offsetdouble[] srcint offint len) {
        long[] values = new long[len];
        for (int i = 0; i < len; ++i) {
            values[i] = Long.reverseBytes(Double.doubleToRawLongBits(src[off + i]));
        }
        .put(offsetvalues, 0, len);
    }
    public final int indexOf(long offsetbyte value) {
        return .indexOf(offsetvalue);
    }
    public final int indexOf(long offsetbyte valueint maxlen) {
        return .indexOf(offsetvaluemaxlen);
    }
    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