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);
 
         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);
         }
     }
 
     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 flagsBlock block) {
         this. = calculateTypeSize(contextrbTypeSize);
         this. = this. * count;
         this. = flags;
         setMemoryIO(allocateMemoryIO(context.runtime, (intthis.));
 
         if (block.isGiven()) {
             block.yield(contextthis);
         }
 
         return this;
     }
 
     @JRubyMethod(name = "initialize", visibility = )
     public IRubyObject initialize(ThreadContext contextIRubyObject sizeArgBlock block) {
         return sizeArg instanceof RubyFixnum
                 ? init(context, RubyFixnum.one(context.runtime),
                     RubyFixnum.fix2int(sizeArg), ( | ), block)
                 : init(contextsizeArg, 1, ( | ), block);
     }
 
    @JRubyMethod(name = "initialize", visibility = )
    public IRubyObject initialize(ThreadContext contextIRubyObject sizeArgIRubyObject arg2Block block) {
        return init(contextsizeArggetCount(arg2), ( | ), block);
    }
    @JRubyMethod(name = "initialize", visibility = )
    public IRubyObject initialize(ThreadContext contextIRubyObject sizeArg,
            IRubyObject countArgIRubyObject clearArgBlock block) {
        return init(contextsizeArg, RubyFixnum.fix2int(countArg), ( | ), block);
    }
    
    
    @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(), getMemoryIO().slice(offset), this. - offsetthis.this.);
    }
    protected AbstractMemory slice(Ruby runtimelong offsetlong size) {
        return new Buffer(runtimegetMetaClass(), getMemoryIO().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);
    }
New to GrepCode? Check out our FAQ X