From: adam <adam@megacz.com>
Date: Wed, 5 Jul 2006 02:08:07 +0000 (-0400)
Subject: checkpoint
X-Git-Tag: tag_for_25-Mar~221
X-Git-Url: http://git.megacz.com/?p=sbp.git;a=commitdiff_plain;h=00bfe640e0ec2ad1765cc2487981713db0475a1a

checkpoint

darcs-hash:20060705020807-5007d-776dcee356630e7af0733272a227989f2af3a3f1.gz
---

diff --git a/src/edu/berkeley/sbp/misc/Demo.java b/src/edu/berkeley/sbp/misc/Demo.java
index 140af81..d1f2243 100644
--- a/src/edu/berkeley/sbp/misc/Demo.java
+++ b/src/edu/berkeley/sbp/misc/Demo.java
@@ -180,14 +180,18 @@ public class Demo {
     }
 
     public static abstract class Target {
-        public abstract String getName();
-        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 String getName() { return _bindable.getSimpleName(); }
+        public tag getTag() { return (tag)_bindable.getAnnotation(tag.class); }
+        public nonterminal getNonTerminal() { return (nonterminal)_bindable.getAnnotation(nonterminal.class); }
+        public String toString() { return _bindable.getSimpleName(); }
+        public Object plant(Object[] fields) { return _bindable.impose(fields); }
+        public boolean isRaw() { return _bindable.isAnnotationPresent(raw.class); }
+        public Object invokeRaw(Iterable<Tree<Object>> t) { _bindable.impose(new Object[] { t }); }
+
         public boolean isCompatible(Production p) {
             tag t = getTag();
             if (t != null &&
@@ -203,6 +207,7 @@ public class Demo {
 
             return false;
         }
+
         public int[] buildSequence(Production p, String[] names, arg[] argtags) {
             int argTagged = 0;
             for(int i=0; i<argtags.length; i++)
@@ -225,11 +230,10 @@ public class Demo {
             }
         }
         public Sequence makeSequence(Production p) {
-            return Sequence.rewritingSequence(new TargetReducer(p, buildSequence(p), "reducer-"+this), p.elements, p.labels, p.drops);
+            return Sequence.rewritingSequence(new TargetReducer(p, buildSequence(p), "reducer-"+this),
+                                              p.elements, p.labels, p.drops);
         }
-        public abstract Object plant(Object[] fields);
-        public boolean isRaw() { return false; }
-        public Object invokeRaw(Iterable<Tree<Object>> t) { return null; }
+
         public class TargetReducer implements Tree.TreeFunctor<Object,Object> {
             private Production p;
             private int[] map;
@@ -267,10 +271,6 @@ public class Demo {
     public static class TargetClass extends Target {
         public final 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 String toString() { return _class.getSimpleName(); }
         public int[] buildSequence(Production p) {
             Field[]  f       = _class.getDeclaredFields();
             String[] names   = new String[f.length];
@@ -286,19 +286,11 @@ public class Demo {
                     return new TargetConstructor(c).buildSequence(p);
             return null;
         }
-        public Object plant(Object[] fields) {
-            return Reflection.impose(_class, fields);
-        }
-        
     }
 
     public static class TargetConstructor extends Target {
         public final Constructor _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); }
-        public String toString() { return _ctor.getName(); }
         public int[] buildSequence(Production p) {
             Annotation[][] annotations = _ctor.getParameterAnnotations();
             int len = annotations.length;
@@ -318,17 +310,10 @@ public class Demo {
                         argtags[i+ofs] = (arg)a;
             return buildSequence(p, names, argtags);
         }
-        public Object plant(Object[] fields) {
-            return Reflection.impose(_ctor, fields);
-        }
     }
     public static class TargetMethod extends Target {
         public final 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 nonterminal getNonTerminal() { return (nonterminal)_method.getAnnotation(nonterminal.class); }
         public int[] buildSequence(Production p) {
             Annotation[][] annotations = _method.getParameterAnnotations();
             String[] names   = new String[annotations.length];
@@ -340,14 +325,6 @@ public class Demo {
             int[] ret = buildSequence(p, names, argtags);
             return ret;
         }
-        public boolean isRaw() { return _method.isAnnotationPresent(raw.class); }
-        public Object invokeRaw(Iterable<Tree<Object>> t) {
-            return Reflection.impose(_method, new Object[] { t });
-        }
-        public Object plant(Object[] fields) {
-            return Reflection.impose(_method, fields);
-        }
-        
     }
 
     public static Union cached = null;
diff --git a/src/edu/berkeley/sbp/util/Reflection.java b/src/edu/berkeley/sbp/util/Reflection.java
index de52785..28676bf 100644
--- a/src/edu/berkeley/sbp/util/Reflection.java
+++ b/src/edu/berkeley/sbp/util/Reflection.java
@@ -327,6 +327,7 @@ public final class Reflection {
         public abstract String getSimpleName();
         public abstract String toString();
         public abstract <A extends Annotation> A getAnnotation(Class<A> c);
+        public abstract Object impose(Object[] fields);
         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);
@@ -342,6 +343,7 @@ public final class Reflection {
         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); }
+        public Object impose(Object[] fields) { return Reflection.impose(_method, fields); }
     }
     private static class BindableConstructor extends Bindable {
         private final Constructor _constructor;
@@ -349,6 +351,7 @@ public final class Reflection {
         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); }
+        public Object impose(Object[] fields) { return Reflection.impose(_constructor, fields); }
     }
     private static class BindableClass extends Bindable {
         private final Class _class;
@@ -356,6 +359,7 @@ public final class Reflection {
         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); }
+        public Object impose(Object[] fields) { return Reflection.impose(_class, fields); }
     }
 
 }