Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ext.ffi.jffi;
  
  import org.jruby.Ruby;
 
 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;
     private final CachingCallSite callSite = new FunctionalCachingCallSite("call");
 
     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) {
         return getCallback(callable);
     }
 
     public final Pointer getCallback(IRubyObject callableCachingCallSite callSite) {
         if (callable instanceof Pointer) {
             return (Pointercallable;
         }
 
         Object ffiHandle = callable.getMetaClass().getRealClass().getFFIHandleAccessorField().getVariableAccessorForRead().get(callable);
         NativeCallbackPointer cbptr;
         if (ffiHandle instanceof NativeCallbackPointer && ((cbptr = (NativeCallbackPointerffiHandle). == )) {
             return cbptr;
         }
 
         return getCallbackPointer(callablecallSite);
     }
 
     private synchronized Pointer getCallbackPointer(IRubyObject callableCachingCallSite callSite) {
         NativeCallbackPointer cbptr = (NativeCallbackPointer.get(callable);
         if (cbptr != null) {
             return cbptr;
         }
 
         .put(callablecbptr = newCallback(callablecallSite));
 
         if (callable.getMetaClass().getFFIHandleAccessorForRead().get(callable) == null) {
             callable.getMetaClass().getFFIHandleAccessorForWrite().set(callablecbptr);
         }
 
         return cbptr;
     }
 
     NativeCallbackPointer newCallback(IRubyObject callableCachingCallSite callSite) {
         if (callSite.retrieveCache(callable.getMetaClass(), callSite.getMethodName())..isUndefined()) {
             throw .newArgumentError("callback does not respond to :" + callSite.getMethodName());
         }
 
         return new NativeCallbackPointer(,
                 .newClosureHandle(new NativeClosureProxy(callablecallSite)),
                 );
     }
 
     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