public abstract tag getTag();
public abstract nonterminal getNonTerminal();
public abstract int[] buildSequence(Production p);
+
+ private Reflection.Bindable _bindable;
+ public Target(Reflection.Bindable b) { this._bindable = b; }
+
public boolean isCompatible(Production p) {
tag t = getTag();
if (t != null &&
public static class TargetClass extends Target {
public final Class _class;
- public TargetClass(Class _class) { this._class = _class; }
+ public TargetClass(Class _class) { super(Reflection.Bindable.create(_class)); this._class = _class; }
public String getName() { return _class.getSimpleName(); }
public tag getTag() { return (tag)_class.getAnnotation(tag.class); }
public nonterminal getNonTerminal() { return (nonterminal)_class.getAnnotation(nonterminal.class); }
public static class TargetConstructor extends Target {
public final Constructor _ctor;
- public TargetConstructor(Constructor _ctor) { this._ctor = _ctor; }
+ public TargetConstructor(Constructor _ctor) { super(Reflection.Bindable.create(_ctor)); this._ctor = _ctor; }
public String getName() { return _ctor.getName(); }
public tag getTag() { return (tag)_ctor.getAnnotation(tag.class); }
public nonterminal getNonTerminal() { return (nonterminal)_ctor.getAnnotation(nonterminal.class); }
return buildSequence(p, names, argtags);
}
public Object plant(Object[] fields) {
- try {
- Class[] argTypes = _ctor.getParameterTypes();
- Object[] args = new Object[argTypes.length];
- int j = 0;
- for(int i=0; i<args.length; i++) {
- Object tgt = Reflection.lub(fields[i]);
- if (argTypes[i] == String.class) tgt = Reflection.stringify(tgt);
- // FUGLY
- tgt = Reflection.coerce(tgt, argTypes[i]);
- System.err.println("setting a " + argTypes[i].getName() + " to " + Reflection.show(tgt));
- args[i] = tgt;
- }
- return _ctor.newInstance(args);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ return Reflection.impose(_ctor, fields);
}
}
public static class TargetMethod extends Target {
public final Method _method;
- public TargetMethod(Method _method) { this._method = _method; }
+ public TargetMethod(Method _method) { super(Reflection.Bindable.create(_method)); this._method = _method; }
public String getName() { return _method.getName(); }
public String toString() { return _method.getName(); }
public tag getTag() { return (tag)_method.getAnnotation(tag.class); }
}
public boolean isRaw() { return _method.isAnnotationPresent(raw.class); }
public Object invokeRaw(Iterable<Tree<Object>> t) {
- try {
- return _method.invoke(null, new Object[] { t });
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ return Reflection.impose(_method, new Object[] { t });
}
public Object plant(Object[] fields) {
- try {
- Class[] argTypes = _method.getParameterTypes();
- Object[] args = new Object[argTypes.length];
- int j = 0;
- for(int i=0; i<args.length; i++) {
- Object tgt = Reflection.lub(fields[i]);
- if (argTypes[i] == String.class) tgt = Reflection.stringify(tgt);
- // FUGLY
- tgt = Reflection.coerce(tgt, argTypes[i]);
- System.err.println("setting a " + argTypes[i].getName() + " to " + Reflection.show(tgt));
- args[i] = tgt;
- }
- System.err.println("invoking " + _method + " with " + Reflection.show(args));
- return _method.invoke(null, args);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ return Reflection.impose(_method, fields);
}
+
}
public static Union cached = null;
package edu.berkeley.sbp.util;
import java.io.*;
import java.lang.reflect.*;
+import java.lang.annotation.*;
/** Random reflection-related utilities */
public final class Reflection {
public static interface Show {
}
+ public static Object impose(Object o, Object[] fields) {
+ if (o instanceof Class) return impose((Class)o, fields);
+ if (o instanceof Method) return impose((Method)o, fields);
+ if (o instanceof Constructor) return impose((Constructor)o, fields);
+ return null;
+ }
public static Object impose(Class _class, Object[] fields) {
try {
Object ret = _class.newInstance();
}
}
+ public static Object impose(Method _method, Object[] fields) {
+ try {
+ Class[] argTypes = _method.getParameterTypes();
+ Object[] args = new Object[argTypes.length];
+ int j = 0;
+ for(int i=0; i<args.length; i++) {
+ Object tgt = Reflection.lub(fields[i]);
+ if (argTypes[i] == String.class) tgt = Reflection.stringify(tgt);
+ // FUGLY
+ tgt = Reflection.coerce(tgt, argTypes[i]);
+ System.err.println("setting a " + argTypes[i].getName() + " to " + Reflection.show(tgt));
+ args[i] = tgt;
+ }
+ System.err.println("invoking " + _method + " with " + Reflection.show(args));
+ return _method.invoke(null, args);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static Object impose(Constructor _ctor, Object[] fields) {
+ try {
+ Class[] argTypes = _ctor.getParameterTypes();
+ Object[] args = new Object[argTypes.length];
+ int j = 0;
+ for(int i=0; i<args.length; i++) {
+ Object tgt = Reflection.lub(fields[i]);
+ if (argTypes[i] == String.class) tgt = Reflection.stringify(tgt);
+ // FUGLY
+ tgt = Reflection.coerce(tgt, argTypes[i]);
+ System.err.println("setting a " + argTypes[i].getName() + " to " + Reflection.show(tgt));
+ args[i] = tgt;
+ }
+ return _ctor.newInstance(args);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
public static String stringify(Object o) {
if (o==null) return "";
if (!(o instanceof Object[])) return o.toString();
return o;
}
+ public static abstract class Bindable {
+ public abstract String getSimpleName();
+ public abstract String toString();
+ public abstract <A extends Annotation> A getAnnotation(Class<A> c);
+ public boolean isAnnotationPresent(Class<? extends Annotation> c) { return getAnnotation(c) != null; }
+ public static Bindable create(Object o) {
+ if (o instanceof Class) return new BindableClass((Class)o);
+ if (o instanceof Method) return new BindableMethod((Method)o);
+ if (o instanceof Constructor) return new BindableConstructor((Constructor)o);
+ return null;
+ }
+ }
+
+ private static class BindableMethod extends Bindable {
+ private final Method _method;
+ public String toString() { return "BindableMethod["+_method+"]"; }
+ public BindableMethod(Method _method) { this._method = _method; }
+ public String getSimpleName() { return _method.getName(); }
+ public <A extends Annotation> A getAnnotation(Class<A> c) { return _method.getAnnotation(c); }
+ }
+ private static class BindableConstructor extends Bindable {
+ private final Constructor _constructor;
+ public String toString() { return "BindableConstructor["+_constructor+"]"; }
+ public BindableConstructor(Constructor _constructor) { this._constructor = _constructor; }
+ public String getSimpleName() { return _constructor.getName(); }
+ public <A extends Annotation> A getAnnotation(Class<A> c) { return _constructor.getAnnotation(c); }
+ }
+ private static class BindableClass extends Bindable {
+ private final Class _class;
+ public String toString() { return "BindableClass["+_class+"]"; }
+ public BindableClass(Class _class) { this._class = _class; }
+ public String getSimpleName() { return _class.getSimpleName(); }
+ public <A extends Annotation> A getAnnotation(Class<A> c) { return (A)_class.getAnnotation(c); }
+ }
+
}