Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi;
  
  
  import org.jruby.Ruby;
 import static org.jruby.runtime.Visibility.*;
 
 @JRubyClass(name = "FFI::MemoryPointer", parent = "FFI::Pointer")
 public final class MemoryPointer extends Pointer {
     
     public static RubyClass createMemoryPointerClass(Ruby runtimeRubyModule module) {
         RubyClass result = module.defineClassUnder("MemoryPointer",
                 module.getClass("Pointer"),
                 .);
         result.defineAnnotatedMethods(MemoryPointer.class);
         result.defineAnnotatedConstants(MemoryPointer.class);
 
         return result;
     }
 
     private static final class MemoryPointerAllocator implements ObjectAllocator {
         static final ObjectAllocator INSTANCE = new MemoryPointerAllocator();
 
         public IRubyObject allocate(Ruby runtimeRubyClass klazz) {
             return new MemoryPointer(runtimeklazz);
         }
     }
 
 
     private MemoryPointer(Ruby runtimeIRubyObject klass) {
         super(runtime, (RubyClassklass);
     }
 
     private MemoryPointer(Ruby runtimeIRubyObject klassDirectMemoryIO iolong totalint typeSize) {
         super(runtime, (RubyClassklassiototaltypeSize);
     }
 
     private final IRubyObject init(ThreadContext contextIRubyObject rbTypeSizeint countint alignboolean clearBlock block) {
          = calculateTypeSize(contextrbTypeSize);
          =  * count;
         if ( < 0) {
             throw context.runtime.newArgumentError(String.format("Negative size (%d objects of %d size)"count));
         }
         setMemoryIO(Factory.getInstance().allocateDirectMemory(context.runtime,
                  > 0 ? (int : 1, alignclear));
         if (getMemoryIO() == null) {
             Ruby runtime = context.runtime;
             throw new RaiseException(runtimeruntime.getNoMemoryError(),
                     String.format("Failed to allocate %d objects of %d bytes"count), true);
         }
         
         if (block.isGiven()) {
             try {
                 return block.yield(contextthis);
             } finally {
                 ((AllocatedDirectMemoryIOgetMemoryIO()).free();
                 setMemoryIO(new FreedMemoryIO(context.runtime));
             }
         } else {
             return this;
         }
     }
 
     static MemoryPointer allocate(Ruby runtimeint typeSizeint countboolean clear) {
         return newInstance(runtimeruntime.getFFI().typeSizecountclear);
     }
 
     static MemoryPointer newInstance(Ruby runtimeIRubyObject klassint typeSizeint countboolean clear) {
         final int total = typeSize * count;
         AllocatedDirectMemoryIO io = Factory.getInstance().allocateDirectMemory(runtimetotal > 0 ? total : 1, clear);
         if (io == null) {
             throw new RaiseException(runtimeruntime.getNoMemoryError(),
                     String.format("Failed to allocate %d objects of %d bytes"counttypeSize), true);
         }
 
         return new MemoryPointer(runtimeklassiototaltypeSize);
     }
 
 
     @JRubyMethod(name = "new", meta = true)
     public static IRubyObject newInstance(ThreadContext contextIRubyObject klassIRubyObject sizeArg) {
         if (klass == context.runtime.getFFI().) {
             return newInstance(context.runtimeklasscalculateTypeSize(contextsizeArg), 1, true);
 
         } else {
             return ((RubyClassklass).newInstance(contextsizeArg.);
         }
    }
    @JRubyMethod(name = "new", meta = true)
    public static IRubyObject newInstance(ThreadContext contextIRubyObject klassIRubyObject sizeArg,
                                          IRubyObject countArg) {
        if (klass == context.runtime.getFFI().) {
            return newInstance(context.runtimeklass,
                    calculateTypeSize(contextsizeArg), RubyFixnum.fix2int(countArg), true);
        } else {
            return ((RubyClassklass).newInstance(contextsizeArgcountArg.);
        }
    }
    @JRubyMethod(name = "new", meta = true)
    public static IRubyObject newInstance(ThreadContext contextIRubyObject klassIRubyObject sizeArg,
                                          IRubyObject countArgIRubyObject clear) {
        if (klass == context.runtime.getFFI().) {
            return newInstance(context.runtimeklass,
                    calculateTypeSize(contextsizeArg), RubyFixnum.fix2int(countArg), clear.isTrue());
        } else {
            return ((RubyClassklass).newInstance(contextsizeArgcountArgclear.);
        }
    }
    @JRubyMethod(name = "new", meta = true, rest = true)
    public static IRubyObject newInstance(ThreadContext contextIRubyObject klassIRubyObject[] args) {
        if (klass == context.runtime.getFFI().) {
            switch (args.length) {
                case 1:
                    return newInstance(contextklassargs[0]);
                case 2:
                    return newInstance(contextklassargs[0], args[1]);
                case 3:
                    return newInstance(contextklassargs[0], args[1], args[2]);
                default:
                    return ((RubyClassklass).newInstance(contextargs.);
            }
        } else {
            return ((RubyClassklass).newInstance(contextargs.);
        }
    }
    @JRubyMethod(name = "from_string", meta = true)
    public static IRubyObject from_string(ThreadContext contextIRubyObject klassIRubyObject s) {
        org.jruby.util.ByteList bl = s.convertToString().getByteList();
        MemoryPointer ptr = klass == context.runtime.getFFI().
            ? newInstance(context.runtimeklass, 1, bl.length() + 1, false)
            : (MemoryPointernewInstance(contextklasscontext.runtime.newFixnum(bl.length() + 1));
        ptr.getMemoryIO().putZeroTerminatedByteArray(0, bl.unsafeBytes(), bl.begin(), bl.length());
        return ptr;
    }
    @JRubyMethod(name = { "initialize" }, visibility = )
    public final IRubyObject initialize(ThreadContext contextIRubyObject sizeArgBlock block) {
        return sizeArg instanceof RubyFixnum
                ? init(context, RubyFixnum.one(context.runtime),
                    RubyFixnum.fix2int(sizeArg), 1, trueblock)
                : init(contextsizeArg, 1, 1, trueblock);
    }
    
    @JRubyMethod(name = { "initialize" }, visibility = )
    public final IRubyObject initialize(ThreadContext contextIRubyObject sizeArgIRubyObject countBlock block) {
        return init(contextsizeArg, RubyNumeric.fix2int(count), 1, trueblock);
    }
    
    @JRubyMethod(name = { "initialize" }, visibility = )
    public final IRubyObject initialize(ThreadContext context,
            IRubyObject sizeArgIRubyObject countIRubyObject clearBlock block) {
        return init(contextsizeArg, RubyNumeric.fix2int(count), 1, clear.isTrue(), block);
    }
    
    @Override
    public final String toString() {
        return String.format("MemoryPointer[address=%#x, size=%d]"getAddress(), );
    }
    @JRubyMethod(name = "==", required = 1)
    public IRubyObject op_equal(ThreadContext contextIRubyObject obj) {
        return context.runtime.newBoolean(this == obj
                || getAddress() == 0L && obj.isNil()
                || (obj instanceof MemoryPointer
                && ((MemoryPointerobj).getAddress() == getAddress())
                && ((MemoryPointerobj).getSize() == getSize());
    }
    
    @JRubyMethod(name = "free")
    public final IRubyObject free(ThreadContext context) {
        ((AllocatedDirectMemoryIOgetMemoryIO()).free();
        // Replace memory object with one that throws an exception on any access
        setMemoryIO(new FreedMemoryIO(context.runtime));
        return context.runtime.getNil();
    }
    @JRubyMethod(name = "autorelease=", required = 1)
    public final IRubyObject autorelease(ThreadContext contextIRubyObject release) {
        ((AllocatedDirectMemoryIOgetMemoryIO()).setAutoRelease(release.isTrue());
        return context.runtime.getNil();
    }
    @JRubyMethod(name = "autorelease?")
    public final IRubyObject autorelease_p(ThreadContext context) {
        return context.runtime.newBoolean(((AllocatedDirectMemoryIOgetMemoryIO()).isAutoRelease());
    }
New to GrepCode? Check out our FAQ X