Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.java.proxies;
  
  import org.jruby.Ruby;
 
 public class ConcreteJavaProxy extends JavaProxy {
 
     public ConcreteJavaProxy(Ruby runtimeRubyClass klazz) {
         super(runtimeklazz);
     }
 
     public ConcreteJavaProxy(Ruby runtimeRubyClass klazzObject object) {
         super(runtimeklazzobject);
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
         public IRubyObject allocate(Ruby runtimeRubyClass klazz) {
             return new ConcreteJavaProxy(runtimeklazz);
         }
     };
 
     public static RubyClass createConcreteJavaProxy(final ThreadContext context) {
         final Ruby runtime = context.runtime;
         final RubyClass JavaProxy = runtime.getJavaSupport().getJavaProxyClass();
         RubyClass ConcreteJavaProxy = runtime.defineClass("ConcreteJavaProxy"JavaProxy);
         initialize(ConcreteJavaProxy);
         return ConcreteJavaProxy;
     }
 
     private static class InitializeMethod extends org.jruby.internal.runtime.methods.JavaMethod {
 
         private final CallSite jcreateSite = MethodIndex.getFunctionalCallSite("__jcreate!");
 
         InitializeMethod(final RubyClass clazz) { super(clazz.); }
 
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
             return .call(contextselfselfargsblock);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameBlock block) {
             return .call(contextselfselfblock);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0Block block) {
             return .call(contextselfselfarg0block);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1Block block) {
             return .call(contextselfselfarg0arg1block);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1IRubyObject arg2Block block) {
             return .call(contextselfselfarg0arg1arg2block);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] args) {
             return .call(contextselfselfargs);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString name) {
             return .call(contextselfself);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0) {
             return .call(contextselfselfarg0);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1) {
             return .call(contextselfselfarg0arg1);
         }
         @Override
         public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1IRubyObject arg2) {
             return .call(contextselfselfarg0arg1arg2);
         }
 
     }
 
     private static class NewMethod extends org.jruby.internal.runtime.methods.JavaMethod {
 
         private final CallSite jcreateSite = MethodIndex.getFunctionalCallSite("__jcreate!");
         final DynamicMethod newMethod;
 
         NewMethod(final RubyClass clazz) {
             super(clazz.);
              = clazz.searchMethod("new");
         }
 
         private static boolean needsCreate(IRubyObject proxy) {
            return ((JavaProxyproxy). == null;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] argsBlock block) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"argsblock);
            if (needsCreate(proxy)) .call(contextproxyproxyargsblock);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameBlock block) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"block);
            if (needsCreate(proxy)) .call(contextproxyproxyblock);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0Block block) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0block);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0block);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1Block block) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0arg1block);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0arg1block);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1IRubyObject arg2Block block) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0arg1arg2block);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0arg1arg2block);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject[] args) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"args);
            if (needsCreate(proxy)) .call(contextproxyproxyargs);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString name) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy");
            if (needsCreate(proxy)) .call(contextproxyproxy);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0arg1);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0arg1);
            return proxy;
        }
        @Override
        public IRubyObject call(ThreadContext contextIRubyObject selfRubyModule clazzString nameIRubyObject arg0IRubyObject arg1IRubyObject arg2) {
            IRubyObject proxy = .call(contextselfclazz"new_proxy"arg0arg1arg2);
            if (needsCreate(proxy)) .call(contextproxyproxyarg0arg1arg2);
            return proxy;
        }
    }
    protected static void initialize(final RubyClass ConcreteJavaProxy) {
        ConcreteJavaProxy.addMethod("initialize"new InitializeMethod(ConcreteJavaProxy));
        // We define a custom "new" method to ensure that __jcreate! is getting called,
        // so that if the user doesn't call super in their subclasses, the object will
        // still get set up properly. See JRUBY-4704.
        RubyClass singleton = ConcreteJavaProxy.getSingletonClass();
        singleton.addMethod("new"new NewMethod(singleton));
    }
    // This alternate ivar logic is disabled because it can cause self-referencing
    // chains to keep the original object alive. See JRUBY-4832.
//    @Override
//    public Object getVariable(int index) {
//        return getRuntime().getJavaSupport().getJavaObjectVariable(this, index);
//    }
//
//    @Override
//    public void setVariable(int index, Object value) {
//        getRuntime().getJavaSupport().setJavaObjectVariable(this, index, value);
//    }

    
Because we can't physically associate an ID with a Java object, we can only use the identity hashcode here.

Returns:
The identity hashcode for the Java object.
    @Override
    public IRubyObject id() {
        return getRuntime().newFixnum(System.identityHashCode(getObject()));
    }
    @Override
    @SuppressWarnings("unchecked")
    public Object toJava(final Class type) {
        final Object object = getObject();
        final Class clazz = object.getClass();
        if ( type.isPrimitive() ) {
            if ( type == . ) return null;
            if ( object instanceof Number && type != . ||
                 object instanceof Character && type == . ||
                 object instanceof Boolean && type == . ) {
                // FIXME in more permissive call paths, like invokedynamic, this can allow
                // precision-loading downcasts to happen silently
                return object;
            }
        }
        else if (type.isAssignableFrom(clazz)) {
            if ( . || .getCacheProxy() ) {
                getRuntime().getJavaSupport().getObjectProxyCache().put(objectthis);
            }
            return object;
        }
        throw getRuntime().newTypeError("failed to coerce " + clazz.getName() + " to " + type.getName());
    }
New to GrepCode? Check out our FAQ X