Runtime Code Generation and operations on unknown types

Question

(Post split in two) - Part 1
Hello,
The problem is a bit more complex so I will try to explain it as good as possible. Let's consider the following classes and interfaces (trimmed to the essential parts):
public abstract class Binding {
  private String name;
  public Binding(String name) {
    this.name = name;
  abstract Object getValue();
  // getters & setters
public interface ExpressionImpl {
  public Object evaluate();
public class DirectBinding extends Binding {
  private String expression;
  private ExpressionImpl exprImpl;
  public DirectBinding(String name, String expression) {
    super(name);
    this.expression = expression;
    this.exprImpl = /* Call to some code which will generate and load a a class that implements "ExpressionImpl" */
  public Object getValue() {
    return exprImpl.evaluate();
public class RecursiveBinding extends Binding {
  private String initializationExpression;
  private String recursiveExpression;
  private ExpressionImpl exprImpl;
  public RecursiveBinding(String name, String initializationExpression, String recursiveExpression)  {
    super(name);
    this.initializationExpression= initializationExpression;
    this.recursiveExpression= recursiveExpression;
    this.exprImpl = /* Call to some code which will generate and load a a class that implements "ExpressionImpl" */
  public Object getValue() {
    return exprImpl.evaluate();
public class Element {
  private List<Element> children;
  private Element parent;
  private List<Binding> bindings;
  // constructor, add, remove, getters and setters
}So:
1. Element models a tree node structure (reference to children and parent) and a binding container.
2. Bindings know their parent element.
3. A Binding can search and access Bindings from it's parent element or this element's ancestors.
4. To observe that Bindings return Object values.
5. Bindings are initialized from top to bottom. So if a child element's binding requires the value of a parent element binding, this is allready available.
6. Valid expressions for DirectBindings are for example:
- "100"
- "3.5D + (new java.util.Random().nextDouble())"
- "$parent_binding + $ancestor_binding"
7. Valid expressions for RecursiveBindings are (initialization expression, recursive expression) (for a Binding called "this_binding"):
- "$parent_binding" , "$this_binding + 1"
- "100", "$this_binding * $ancestor_binding"
8. A Binding object deals with values of the same type in it's expression(s) -> only numeric, only boolean. You cannot have "$parent_binding && true" if "parent_binding" returns an Integer object (through it's "Object getValue()" method).
9. Instead of parsing and evaluating the expressions as strings, classes are generated which return the natural (Java) evaluation of the expressions. Of course valid code will be generated for the expression, so if a binding reference is found, in the generated class it will be replaced with the equivalent "binding.getValue()".

Answer 1

Part 2
Let's consider the following code snippet:
Element parent = new Element("parent");
parent.addBinding(new DirectBinding("parent_binding", "3.5D"); // Will call this Binding 1
Element child = new Element("child");
child.addBinding(new DirectBinding("child_direct_binding", "$parent_binding + 1"); // Will call this Binding 2
child.addBinding(new RecursiveBinding("child_recursive_binding", "10", "$child_recursive_binding + Math.PI"); // Will call this Binding 3
parent.add(child);
parent.initialize(); // this is where the code generation starts (top to bottom)Now the following classes are generated:
Binding 1 expression implementation:
public class EMC_parent_binding implements ExpressionImpl {
     public EMC_parent_binding(final BindingCache bindingCache) {
     public Object evaluate() {
          return 3.5D;
//Binding 2 expression implementation:
public class EMC_child_direct_binding implements ExpressionImpl {
     private Binding m_parent_binding;
     public EMC_child_direct_binding(final BindingCache bindingCache) {
          m_parent_binding = bindingCache.getBinding("parent_binding");
     public Object evaluate() {
          return (java.lang.Double)(m_parent_binding.getValue()) + 1;
// Binding 3 expression implementation:
public class EMC_child_recursive_binding implements ExpressionImpl {
     private boolean firstEvaluation = true;
     private Binding m_child_recursive_binding;
     public EMC_child_recursive_binding(final BindingCache bindingCache) {
          m_child_recursive_binding = bindingCache.getBinding("child_recursive_binding");
     public Object evaluate() {
          if (firstEvaluation) {
               firstEvaluation = false;
               return 10;
          } else {
               return (UnkownType)(m_child_recursive_binding.getValue()) + Math.PI;  // <-------- This is where the problem appears
}Notice the casts in the evaluate() methods. Since I cannot do operations on "Object" I needed to cast to the appropriate types. This is easy to notice in Binding 2. It's easy to cast to "java.lang.Double" since when generating the code I allready have the value of "parent_binding" and thereby know it's type.
Now the problem appears at recursive bindings (code for Binding 3). The binding for which I currently generate the code has a value of "null" and cannot find an appropriate type to cast to. How can I find a type to cast to, or what other solutions do I have?
I sincerely thank you for reading this whole post, and am looking forward for some replies.
Kind regards,
Cosmin.