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;
 import static org.jruby.runtime.Visibility.*;
 
 
 @JRubyClass(name = "FFI::Buffer", parent = "FFI::" + .)
 public final class Buffer extends AbstractMemory {
    
Indicates that the Buffer is used for data copied IN to native memory
 
     public static final int IN = 0x1;

    
Indicates that the Buffer is used for data copied OUT from native memory
 
     public static final int OUT = 0x2;
     
     private int inout;
 
     public static RubyClass createBufferClass(Ruby runtimeRubyModule module) {
         RubyClass result = module.defineClassUnder("Buffer",
                 module.getClass(.),
                 .);
         result.defineAnnotatedMethods(Buffer.class);
         result.defineAnnotatedConstants(Buffer.class);
 //        result.getSingletonClass().addMethod("new", new NewInstanceMethod(result.getRealClass()));
 
         return result;
     }
 
     private static final class BufferAllocator implements ObjectAllocator {
         static final ObjectAllocator INSTANCE = new BufferAllocator();
 
         public IRubyObject allocate(Ruby runtimeRubyClass klazz) {
             return new Buffer(runtimeklazz);
         }
     }
 
     private static final class NewInstanceMethod extends DynamicMethod {
         private final NativeCall new1new2new3;
         private NewInstanceMethod(RubyModule implementationClass) {
             super(implementationClass..);
 
              = new NativeCall(Buffer.class"newInstance"IRubyObject.class,
                     new Class[] { ThreadContext.classIRubyObject.classIRubyObject.class }, truefalse);
              = new NativeCall(Buffer.class"newInstance"IRubyObject.class,
                     new Class[] { ThreadContext.classIRubyObject.classIRubyObject.classIRubyObject.class }, truefalse);
              = new NativeCall(Buffer.class"newInstance"IRubyObject.class,
                     new Class[] { ThreadContext.classIRubyObject.classIRubyObject.classIRubyObject.classIRubyObject.class }, truefalse);
         }
 
         @Override
         public DynamicMethod dup() {
             return this;
         }
 
         @Override
         public Arity getArity() {
             return Arity.fixed(1);
         }
 
         @Override
         public NativeCall getNativeCall() {
             return ;
         }
 
         @Override
         public void setHandle(Object handle) {}
 
         @Override
         public NativeCall getNativeCall(int argsboolean block) {
             switch (args) {
                 case 1:
                     return ;
                 case 2:
                     return ;
                 case 3:
                     return ;
             }
             return super.getNativeCall(argsblock);    //To change body of overridden methods use File | Settings | File Templates.
         }
 
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
             switch (args.length) {
                 case 1:
                     return call(contextselfclazznameargs[0]);
 
                 case 2:
                case 3:
                    return call(contextselfclazznameargs[0], args[1]);
                default:
                    return ((RubyClassself).newInstance(contextargsblock);
            }
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule klazzString name,
                                IRubyObject arg0) {
            return Buffer.newInstance(contextselfarg0);
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule klazzString name,
                                IRubyObject arg0IRubyObject arg1) {
            return Buffer.newInstance(contextselfarg0arg1);
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule klazzString name,
                                IRubyObject arg0IRubyObject arg1IRubyObject arg2) {
            return Buffer.newInstance(contextselfarg0arg1);
        }
    }
    public Buffer(Ruby runtimeRubyClass klass) {
        super(runtimeklassruntime.getFFI().getNullMemoryIO(), 0, 0);
        this. =  | ;
    }
    
    public Buffer(Ruby runtimeint size) {
        this(runtimesize | );
    }
    
    public Buffer(Ruby runtimeint sizeint flags) {
        this(runtimeruntime.getFFI().,
            allocateMemoryIO(runtimesize), size, 1, flags);
    }
    private Buffer(Ruby runtimeIRubyObject klassMemoryIO iolong sizeint typeSizeint inout) {
        super(runtime, (RubyClassklassiosizetypeSize);
        this. = inout;
    }
    
    private static final int getCount(IRubyObject countArg) {
        return countArg instanceof RubyFixnum ? RubyFixnum.fix2int(countArg) : 1;
    }
    
    private static Buffer allocate(ThreadContext contextIRubyObject recv
            IRubyObject sizeArgint countint flags) {
        final int typeSize = calculateTypeSize(contextsizeArg);
        final int total = typeSize * count;
        return new Buffer(context.runtimerecv,
                allocateMemoryIO(context.runtimetotal), totaltypeSizeflags);
    }
    private IRubyObject init(ThreadContext contextIRubyObject rbTypeSizeint countint flags) {
        this. = calculateTypeSize(contextrbTypeSize);
        this. = this. * count;
        this. = flags;
        setMemoryIO(allocateMemoryIO(context.runtime, (intthis.));
        return this;
    }
    @JRubyMethod(name = "new", meta = true)
    public static IRubyObject newInstance(ThreadContext contextIRubyObject klassIRubyObject sizeArg) {
        if (klass == context.runtime.getFFI().) {
            return allocate(contextklasssizeArg, 1,  | );
        } 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 allocate(contextklasssizeArg, RubyFixnum.fix2int(countArg),  | );
        } 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 allocate(contextklasssizeArg, RubyFixnum.fix2int(countArg),  | );
        } 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:
                case 3:
                    return newInstance(contextklassargs[0], args[1]);
                default:
                    return ((RubyClassklass).newInstance(contextargs.);
            }
        } else {
            return ((RubyClassklass).newInstance(contextargs.);
        }
    }
    @JRubyMethod(name = "initialize", visibility = )
    public IRubyObject initialize(ThreadContext contextIRubyObject sizeArg) {
        return sizeArg instanceof RubyFixnum
                ? init(context, RubyFixnum.one(context.runtime),
                    RubyFixnum.fix2int(sizeArg),  | )
                : init(contextsizeArg, 1,  | );
    }
    @JRubyMethod(name = "initialize", visibility = )
    public IRubyObject initialize(ThreadContext contextIRubyObject sizeArgIRubyObject arg2) {
        return init(contextsizeArggetCount(arg2),  | );
    }
    @JRubyMethod(name = "initialize", visibility = )
    public IRubyObject initialize(ThreadContext contextIRubyObject sizeArg,
            IRubyObject countArgIRubyObject clearArg) {
        return init(contextsizeArg, RubyFixnum.fix2int(countArg),  | );
    }
    
    
    @JRubyMethod(required = 1, visibility=)
    public IRubyObject initialize_copy(ThreadContext contextIRubyObject other) {
        if (this == other) {
            return this;
        }
        Buffer orig = (Bufferother;
        this. = orig.typeSize;
        this. = orig.size;
        this. = orig.inout;
        
        setMemoryIO(orig.getMemoryIO().dup());
        return this;
    }
    @JRubyMethod(name = { "alloc_inout""__alloc_inout" }, meta = true)
    public static Buffer allocateInOut(ThreadContext contextIRubyObject recvIRubyObject sizeArg) {
        return allocate(contextrecvsizeArg, 1,  | );
    }
    @JRubyMethod(name = { "alloc_inout""__alloc_inout" }, meta = true)
    public static Buffer allocateInOut(ThreadContext contextIRubyObject recv,
            IRubyObject sizeArgIRubyObject arg2) {
        return allocate(contextrecvsizeArggetCount(arg2),  | );
    }
    @JRubyMethod(name = { "alloc_inout""__alloc_inout" }, meta = true)
    public static Buffer allocateInOut(ThreadContext contextIRubyObject recv
            IRubyObject sizeArgIRubyObject countArgIRubyObject clearArg) {
        return allocate(contextrecvsizeArg, RubyFixnum.fix2int(countArg),  | );
    }
    @JRubyMethod(name = { "new_in""alloc_in""__alloc_in" }, meta = true)
    public static Buffer allocateInput(ThreadContext contextIRubyObject recvIRubyObject arg) {       
        return allocate(contextrecvarg, 1, );
    }
    @JRubyMethod(name = { "new_in""alloc_in""__alloc_in" }, meta = true)
    public static Buffer allocateInput(ThreadContext contextIRubyObject recvIRubyObject sizeArgIRubyObject arg2) {
        return allocate(contextrecvsizeArggetCount(arg2), );
    }
    @JRubyMethod(name = { "new_in""alloc_in""__alloc_in" }, meta = true)
    public static Buffer allocateInput(ThreadContext contextIRubyObject recv,
            IRubyObject sizeArgIRubyObject countArgIRubyObject clearArg) {
        return allocate(contextrecvsizeArg, RubyFixnum.fix2int(countArg), );
    }
    @JRubyMethod(name = {  "new_out""alloc_out""__alloc_out" }, meta = true)
    public static Buffer allocateOutput(ThreadContext contextIRubyObject recvIRubyObject sizeArg) {
        return allocate(contextrecvsizeArg, 1, );
    }
    @JRubyMethod(name = {  "new_out""alloc_out""__alloc_out" }, meta = true)
    public static Buffer allocateOutput(ThreadContext contextIRubyObject recvIRubyObject sizeArgIRubyObject arg2) {
        return allocate(contextrecvsizeArggetCount(arg2), );
    }
    @JRubyMethod(name = {  "new_out""alloc_out""__alloc_out" }, meta = true)
    public static Buffer allocateOutput(ThreadContext contextIRubyObject recv,
            IRubyObject sizeArgIRubyObject countArgIRubyObject clearArg) {
        return allocate(contextrecvsizeArg, RubyFixnum.fix2int(countArg), );
    }
    @JRubyMethod(name = "inspect")
    public IRubyObject inspect(ThreadContext context) {
        return RubyString.newString(context.runtime,
                String.format("#<Buffer size=%d>"));
    }
    
    public final AbstractMemory order(Ruby runtimeByteOrder order) {
        return new Buffer(runtimegetMetaClass(),
                order.equals(getMemoryIO().order()) ? getMemoryIO() : new SwappedMemoryIO(runtimegetMemoryIO()),
                );
    }
    protected AbstractMemory slice(Ruby runtimelong offset) {
        return new Buffer(runtimegetMetaClass(), this..slice(offset), this. - offsetthis.this.);
    }
    protected AbstractMemory slice(Ruby runtimelong offsetlong size) {
        return new Buffer(runtimegetMetaClass(), this..slice(offsetsize), sizethis.this.);
    }
    protected Pointer getPointer(Ruby runtimelong offset) {
        return new Pointer(runtimegetMemoryIO().getMemoryIO(offset));
    }
    public int getInOutFlags() {
        return ;
    }
    
    private static MemoryIO allocateMemoryIO(Ruby runtimeint size) {
        return Factory.getInstance().allocateTransientDirectMemory(runtimesize, 8, true);
    }