Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ext.ffi.jffi;
  
  import org.jruby.Ruby;
  import org.jruby.RubyProc;
 
 public class NativeCallbackFactory {
     private final WeakIdentityHashMap closures = new WeakIdentityHashMap();
     private final Ruby runtime;
     private final ClosurePool closurePool;
     private final NativeFunctionInfo closureInfo;
     private final CallbackInfo callbackInfo;
     private final RubyClass callbackClass;
 
     public NativeCallbackFactory(Ruby runtimeCallbackInfo cbInfo) {
         this. = runtime;
         this. = newFunctionInfo(runtimecbInfo);
         this. = com.kenai.jffi.ClosureManager.getInstance().getClosurePool(.);
         this. = cbInfo;
         this. = runtime.getModule("FFI").getClass("Callback");
     }
 
     public final Pointer getCallback(RubyObject callable) {
         if (callable instanceof Pointer) {
             return (Pointercallable;
         }
 
         Object ffiHandle = callable.getFFIHandle();
         NativeCallbackPointer cbptr;
         if (ffiHandle instanceof NativeCallbackPointer && ((cbptr = (NativeCallbackPointerffiHandle). == )) {
             return cbptr;
         }
 
         synchronized (callable) {
             cbptr = (NativeCallbackPointer.get(callable);
             if (cbptr != null) {
                 return cbptr;
             }
 
             cbptr = newCallback(callable);
 
             if (callable.getFFIHandle() == null) {
                 callable.setFFIHandle(cbptr);
             } else {
                 .put(callablecbptr);
             }
 
             return cbptr;
         }
     }
 
         if (!(callable instanceof RubyProc) && !callable.respondsTo("call")) {
             throw .newArgumentError("callable does not respond to :call");
         }
 
         return new NativeCallbackPointer(,
                 .newClosureHandle(new NativeClosureProxy(callable)),
                 );
     }
 
     NativeCallbackPointer newCallback(Object callable) {
         return new NativeCallbackPointer(,
                 .newClosureHandle(new NativeClosureProxy(callable)),
                 );
     }
 
     private final NativeFunctionInfo newFunctionInfo(Ruby runtimeCallbackInfo cbInfo) {
 
         org.jruby.ext.ffi.Type[] paramTypes = cbInfo.getParameterTypes();
         for (int i = 0; i < paramTypes.length; ++i) {
             if (!isParameterTypeValid(paramTypes[i]) || FFIUtil.getFFIType(paramTypes[i]) == null) {
                 throw runtime.newTypeError("invalid callback parameter type: " + paramTypes[i]);
             }
         }
 
         if (!isReturnTypeValid(cbInfo.getReturnType()) || FFIUtil.getFFIType(cbInfo.getReturnType()) == null) {
             runtime.newTypeError("invalid callback return type: " + cbInfo.getReturnType());
         }
 
         return new NativeFunctionInfo(runtimecbInfo.getReturnType(), cbInfo.getParameterTypes(),
                 cbInfo.isStdcall() ? . : .);
     }


    
Checks if a type is a valid callback return type

Parameters:
type The type to examine
Returns:
true if type is a valid return type for a callback.
    private static final boolean isReturnTypeValid(Type type) {
        if (type instanceof Type.Builtin) {
            switch (type.getNativeType()) {
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                    return true;
            }
        } else if (type instanceof CallbackInfo) {
            return true;
        } else if (type instanceof StructByValue) {
            return true;
        }
        return false;
    }

    
Checks if a type is a valid parameter type for a callback

Parameters:
type The type to examine
Returns:
true if type is a valid parameter type for a callback.
    private static final boolean isParameterTypeValid(Type type) {
        if (type instanceof Type.Builtin) {
            switch (type.getNativeType()) {
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                case :
                    return true;
            }
        } else if (type instanceof CallbackInfo) {
            return true;
        } else if (type instanceof StructByValue) {
            return true;
        } else if (type instanceof MappedType) {
            return isParameterTypeValid(((MappedTypetype).getRealType());
        }
        return false;
    }
New to GrepCode? Check out our FAQ X