Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi;
  
  import java.nio.ByteOrder;
  import org.jruby.Ruby;
Defines memory operations for a primitive type
 
 abstract class MemoryOp {
     public static final MemoryOp BOOL = new BooleanOp();
     public static final MemoryOp INT8 = new Signed8();
     public static final MemoryOp UINT8 = new Unsigned8();
     public static final MemoryOp INT16 = new Signed16();
     public static final MemoryOp UINT16 = new Unsigned16();
     public static final MemoryOp INT32 = new Signed32();
     public static final MemoryOp UINT32 = new Unsigned32();
     public static final MemoryOp INT64 = new Signed64();
     public static final MemoryOp UINT64 = new Unsigned64();
     public static final MemoryOp FLOAT32 = new Float32();
     public static final MemoryOp FLOAT64 = new Float64();
     public static final MemoryOp INT16SWAP = new Signed16Swapped();
     public static final MemoryOp UINT16SWAP = new Unsigned16Swapped();
     public static final MemoryOp INT32SWAP = new Signed32Swapped();
     public static final MemoryOp UINT32SWAP = new Unsigned32Swapped();
     public static final MemoryOp INT64SWAP = new Signed64Swapped();
     public static final MemoryOp UINT64SWAP = new Unsigned64Swapped();
     public static final MemoryOp POINTER = new PointerOp();
 
     public static MemoryOp getMemoryOp(NativeType type) {
         return getMemoryOp(type, ByteOrder.nativeOrder());
     }
     
     public static MemoryOp getMemoryOp(NativeType typeByteOrder order) {
         switch (type) {
             case :
                 return ;
             case :
                 return ;
             case :
                 return ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return order.equals(ByteOrder.nativeOrder()) ?  : ;
             case :
                 return ;
             case :
                 return ;
             case :
                 return Platform.getPlatform().longSize() == 32
                         ? getMemoryOp(.order) : getMemoryOp(.order);
             case :
                 return Platform.getPlatform().longSize() == 32
                         ? getMemoryOp(.order) : getMemoryOp(.order);
             case :
                 return ;
             default:
                 return null;
         }
     }
 
     public static MemoryOp getMemoryOp(Type type) {
         return getMemoryOp(type, ByteOrder.nativeOrder());
     }
 
     public static MemoryOp getMemoryOp(Type typeByteOrder order) {
         if (type instanceof Type.Builtin) {
             return getMemoryOp(type.getNativeType(), order);
 
         } else if (type instanceof StructByValue) {
             StructByValue sbv = (StructByValuetype;
             return new StructOp(sbv.getStructClass());
         
         } else if (type instanceof MappedType) {
             return new Mapped(getMemoryOp(((MappedTypetype).getRealType(), order), (MappedTypetype);
         }
 
         return null;
     }
     
     abstract IRubyObject get(ThreadContext contextMemoryIO iolong offset);
     abstract void put(ThreadContext contextMemoryIO iolong offsetIRubyObject value);
     
     IRubyObject get(ThreadContext contextAbstractMemory ptrlong offset) {
         return get(contextptr.getMemoryIO(), offset);
     }
    void put(ThreadContext contextAbstractMemory ptrlong offsetIRubyObject value) {
        put(contextptr.getMemoryIO(), offsetvalue);
    }
    static abstract class PrimitiveOp extends MemoryOp {
        abstract IRubyObject get(Ruby runtimeMemoryIO iolong offset);
        abstract void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value);
    
        IRubyObject get(ThreadContext contextMemoryIO iolong offset) {
            return get(context.runtimeiooffset);
        }
        void put(ThreadContext contextMemoryIO iolong offsetIRubyObject value) {
            put(context.runtimeiooffsetvalue);
        }
    }
    static final class BooleanOp extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putByte(offset, (byte) (value.isTrue() ? 1 : 0));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return runtime.newBoolean(io.getByte(offset) != 0);
        }
    }
    static final class Signed8 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putByte(offset, Util.int8Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned8(runtimeio.getByte(offset));
        }
    }
    static final class Unsigned8 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putByte(offset, (byte) Util.uint8Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned8(runtimeio.getByte(offset));
        }
    }
    static final class Signed16 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putShort(offset, Util.int16Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned16(runtimeio.getShort(offset));
        }
    }
    static final class Signed16Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putShort(offset, Short.reverseBytes(Util.int16Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned16(runtime, Short.reverseBytes(io.getShort(offset)));
        }
    }
    static final class Unsigned16 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putShort(offset, (short) Util.uint16Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned16(runtimeio.getShort(offset));
        }
    }
    
    static final class Unsigned16Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putShort(offset, Short.reverseBytes((short) Util.uint16Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned16(runtime, Short.reverseBytes(io.getShort(offset)));
        }
    }
    static final class Signed32 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putInt(offset, Util.int32Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned32(runtimeio.getInt(offset));
        }
    }
    static final class Signed32Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putInt(offset, Integer.reverseBytes(Util.int32Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned32(runtime, Integer.reverseBytes(io.getInt(offset)));
        }
    }
    static final class Unsigned32 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putInt(offset, (int) Util.uint32Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned32(runtimeio.getInt(offset));
        }
    }
    static final class Unsigned32Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putInt(offset, Integer.reverseBytes((int) Util.uint32Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned32(runtime, Integer.reverseBytes(io.getInt(offset)));
        }
    }
    
    static final class Signed64 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putLong(offset, Util.int64Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned64(runtimeio.getLong(offset));
        }
    }
    static final class Signed64Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putLong(offset, Long.reverseBytes(Util.int64Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newSigned64(runtime, Long.reverseBytes(io.getLong(offset)));
        }
    }
    static final class Unsigned64 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putLong(offset, Util.uint64Value(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned64(runtimeio.getLong(offset));
        }
    }
    static final class Unsigned64Swapped extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putLong(offset, Long.reverseBytes(Util.uint64Value(value)));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return Util.newUnsigned64(runtime, Long.reverseBytes(io.getLong(offset)));
        }
    }
    
    static final class Float32 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putFloat(offset, Util.floatValue(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return runtime.newFloat(io.getFloat(offset));
        }
    }
    
    static final class Float64 extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putDouble(offset, Util.doubleValue(value));
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return runtime.newFloat(io.getDouble(offset));
        }
    }
    static final class PointerOp extends PrimitiveOp {
        public final void put(Ruby runtimeMemoryIO iolong offsetIRubyObject value) {
            io.putMemoryIO(offset, ((AbstractMemoryvalue).getMemoryIO());
        }
        public final IRubyObject get(Ruby runtimeMemoryIO iolong offset) {
            return new Pointer(runtimeio.getMemoryIO(offset));
        }
    }
    
    static final class StructOp extends MemoryOp {
        private final RubyClass structClass;
        public StructOp(RubyClass structClass) {
            this. = structClass;
        }
        @Override
        IRubyObject get(ThreadContext contextMemoryIO iolong offset) {
            throw new UnsupportedOperationException("Not supported yet.");
        }
        @Override
        void put(ThreadContext contextMemoryIO iolong offsetIRubyObject value) {
            throw new UnsupportedOperationException("Not supported yet.");
        }
        @Override
        IRubyObject get(ThreadContext contextAbstractMemory ptrlong offset) {
            return .newInstance(context,
                        new IRubyObject[] { ptr.slice(context.runtimeoffset) },
                        .);
        }
        @Override
        void put(ThreadContext contextAbstractMemory ptrlong offsetIRubyObject value) {
            if (!(value instanceof Struct)) {
                throw context.runtime.newTypeError("expected a struct");
            }
            Struct s = (Structvalue;
            byte[] tmp = new byte[Struct.getStructSize(context.runtimes)];
            s.getMemoryIO().get(0, tmp, 0, tmp.length);
            ptr.getMemoryIO().put(offsettmp, 0, tmp.length);
        }
    }
    
    static final class Mapped extends MemoryOp {
        private final MemoryOp nativeOp;
        private final MappedType mappedType;
        public Mapped(MemoryOp nativeOpMappedType mappedType) {
            this. = nativeOp;
            this. = mappedType;
        }
        @Override
        IRubyObject get(ThreadContext contextAbstractMemory ptrlong offset) {
            return .fromNative(context.get(contextptroffset));
        }
        @Override
        void put(ThreadContext contextAbstractMemory ptrlong offsetIRubyObject value) {
            .put(contextptroffset.toNative(contextvalue));
        }
        
        @Override
        IRubyObject get(ThreadContext contextMemoryIO iolong offset) {
            return .fromNative(context.get(contextiooffset));
        }
        @Override
        void put(ThreadContext contextMemoryIO iolong offsetIRubyObject value) {
            .put(contextiooffset.toNative(contextvalue));
        }
    }