Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 
   */
  
  package org.jruby.ext.ffi;
  
  
  import org.jruby.Ruby;
A type which represents a conversion to/from a native type.
 
 @JRubyClass(name="FFI::Type::Mapped", parent="FFI::Type")
 public final class MappedType extends Type {
     private final Type realType;
     private final IRubyObject converter;
     private final boolean isReferenceRequired;
     private final CachingCallSite toNativeCallSite = new FunctionalCachingCallSite("to_native");
     private final CachingCallSite fromNativeCallSite = new FunctionalCachingCallSite("from_native");
 
     public static RubyClass createConverterTypeClass(Ruby runtimeRubyModule ffiModule) {
         RubyClass convClass = ffiModule.getClass("Type").defineClassUnder("Mapped"ffiModule.getClass("Type"),
                 .);
         convClass.defineAnnotatedMethods(MappedType.class);
         convClass.defineAnnotatedConstants(MappedType.class);
 
 
         return convClass;
     }
 
     private MappedType(Ruby runtimeRubyClass klassType nativeTypeIRubyObject converterboolean isRefererenceRequired) {
         super(runtimeklass.nativeType.getNativeSize(), nativeType.getNativeAlignment());
         this. = nativeType;
         this. = converter;
         this. = isRefererenceRequired;
     }
 
     @JRubyMethod(name = "new", meta = true)
     public static final IRubyObject newMappedType(ThreadContext contextIRubyObject klassIRubyObject converter) {
         if (!converter.respondsTo("native_type")) {
             throw context.runtime.newNoMethodError("converter needs a native_type method""native_type"converter.getMetaClass());
         }
 
         Type nativeType;
         try {
             nativeType = (Typeconverter.callMethod(context"native_type");
         } catch (ClassCastException ex) {
             throw context.runtime.newTypeError("native_type did not return instance of FFI::Type");
         }
 
         boolean isReferenceRequired;
         if (converter.respondsTo("reference_required?")) {
             isReferenceRequired = converter.callMethod(context"reference_required?").isTrue();
 
         } else {
             switch (nativeType.nativeType) {
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                 case :
                     isReferenceRequired = false;
                     break;
 
                 default:
                     isReferenceRequired = true;
                     break;
             }
         }
 
         return new MappedType(context.runtime, (RubyClassklassnativeTypeconverterisReferenceRequired);
     }
     
     public final Type getRealType() {
         return ;
     }
 
     public final boolean isReferenceRequired() {
         return ;
     }
 
    public final boolean isPostInvokeRequired() {
        return false;
    }
    public final IRubyObject native_type(ThreadContext context) {
        return ;
    }
    public final IRubyObject from_native(ThreadContext contextIRubyObject valueIRubyObject ctx) {
        return fromNative(contextvalue);
    }
    public final IRubyObject to_native(ThreadContext contextIRubyObject valueIRubyObject ctx) {
        return toNative(contextvalue);
    }
    public final IRubyObject fromNative(ThreadContext contextIRubyObject value) {
        return .call(contextthisvaluecontext.runtime.getNil());
    }
    public final IRubyObject toNative(ThreadContext contextIRubyObject value) {
        return .call(contextthisvaluecontext.runtime.getNil());
    }
New to GrepCode? Check out our FAQ X