Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  
  package org.jruby.ext.ffi;
  
  import org.jruby.Ruby;
 
 
 
 @JRubyClass(name="FFI::StructByReference", parent="Object")
 public final class StructByReference extends RubyObject {
     private final StructLayout structLayout;
     private final RubyClass structClass;
 
     public static RubyClass createStructByReferenceClass(Ruby runtimeRubyModule ffiModule) {
         RubyClass sbrClass = ffiModule.defineClassUnder("StructByReference"runtime.getObject(),
                 .);
         sbrClass.defineAnnotatedMethods(StructByReference.class);
         sbrClass.defineAnnotatedConstants(StructByReference.class);
         sbrClass.includeModule(ffiModule.getConstant("DataConverter"));
 
         return sbrClass;
     }
 
 
 
     @JRubyMethod(name = "new", meta = true)
     public static final IRubyObject newStructByReference(ThreadContext contextIRubyObject klassIRubyObject structClass) {
         if (!(structClass instanceof RubyClass)) {
             throw context.runtime.newTypeError("wrong argument type "
                     + structClass.getMetaClass().getName() + " (expected Class)");
         }
 
         if (!((RubyClassstructClass).isKindOfModule(context.runtime.getFFI().)) {
             throw context.runtime.newTypeError("wrong argument type "
                     + structClass.getMetaClass().getName() + " (expected subclass of FFI::Struct)");
         }
 
         return new StructByReference(context.runtime, (RubyClassklass,
                 (RubyClassstructClass, Struct.getStructLayout(context.runtimestructClass));
     }
 
     private StructByReference(Ruby runtimeRubyClass klassRubyClass structClassStructLayout layout) {
         super(runtimeklass);
         this. = structClass;
         this. = layout;
     }
 
     @JRubyMethod(name = "to_s")
     public final IRubyObject to_s(ThreadContext context) {
         return RubyString.newString(context.runtime, String.format("#<FFI::StructByReference:%s>".getName()));
     }
 
     @JRubyMethod(name = "layout")
     public final IRubyObject layout(ThreadContext context) {
         return ;
     }
 
     @JRubyMethod(name = "struct_class")
     public final IRubyObject struct_class(ThreadContext context) {
         return ;
     }
 
     @JRubyMethod(name = "native_type")
     public IRubyObject native_type(ThreadContext context) {
         return context.runtime.getFFI()..getConstant("POINTER");
     }
 
 
     @JRubyMethod(name = "to_native")
     public IRubyObject to_native(ThreadContext contextIRubyObject valueIRubyObject ctx) {
         if (value instanceof Struct) {
             return ((Structvalue).getMemory();
 
         } else if (value.isNil()) {
             return Pointer.getNull(context.runtime);
 
         } else {
             throw context.runtime.newTypeError(valuecontext.runtime.getFFI().);
         }
     }
 
     @JRubyMethod(name = "from_native")
     public IRubyObject from_native(ThreadContext contextIRubyObject valueIRubyObject ctx) {
         if (value instanceof AbstractMemory) {
             return getStructClass().newInstance(contextvalue.);
 
         } else if (value.isNil()) {
             return getStructClass().newInstance(context, Pointer.getNull(context.runtime), .);
 
         } else {
            throw context.runtime.newTypeError(valuecontext.runtime.getFFI().);
        }
    }
    @JRubyMethod(name = "reference_required?")
    public IRubyObject reference_required_p(ThreadContext context) {
        return context.runtime.getFalse();
    }
    public final StructLayout getStructLayout() {
        return ;
    }
    public final RubyClass getStructClass() {
        return ;
    }
New to GrepCode? Check out our FAQ X