On Sat, 27 Nov 2010, Alexander Burger wrote:
Hi markspace,
This could still be made to work, even for the generic case. Can you
tell us more about the context? There's a short cut if you are using
the Proxy class, otherwise you'll have to go about it the longer way.
How would that longer way look like?
About the context I just wrote in another reply, so I don't repeat it
here.
There must be a way, because the combination of Java compiler and runtime
system does exactly the same.
One option would be to sidestep the problem of reproducing what the
compiler does, and just use the compiler. Could you generate little source
fragments at runtime with the relevant inputs, then compile them to
bytecode on the fly? If you had an interface like:
public interface Invoker {
public Object invoke(Object receiver, Object... params);
}
Then when you're in the situation that the receiver is a
javax.swing.JPanel (i'm guessing here), the method is called "add", and
there is one parameter, a javax.swing.JTextArea, you would generate code
like this (from a very simple template - note that all the types are based
on the runtime class of the parameters you happen to have at the time,
which is easily determined):
class javax$swing$JPanel_add_javax$swing$JTextArea implements Invoker {
public Object invoke(Object receiver, Object... params) {
javax.swing.JPanel castReceiver = (javax.swing.JPanel)receiver;
if (params.length != 1) throw new IllegalArgumentException(); // or
something more appropriate
javax.swing.JTextArea param0 = (javax.swing.JTextArea)params[0];
// you also need to do something about exceptions
return castReceiver.add(param0);
}
}
Compile it, put the generated class file on your classpath,
generated. It could probably also be the cache you describe below.
then load it and use it. You would keep a global cache of generated
invokers, and reuse them rather than generating them afresh where you
could.
Clever. I think Invoker.invoke() throws InvocationException, by the way.