EvaluatingContext.java

Violations

Source code

/*
  * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
  */
package biz.hammurapi.eval;

import java.io.StringReader;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;

import antlr.RecognitionException;
import antlr.TokenStreamException;
import biz.hammurapi.antlr.AST;
import biz.hammurapi.antlr.Token;
import biz.hammurapi.config.BeanContext;
import biz.hammurapi.config.Context;
import biz.hammurapi.convert.Converter;


/**
 * @author Pavel Vlasov
 * @revision $Revision$
 */
public class EvaluatingContext implements Context {
	private static final Logger logger=Logger.getLogger(EvaluatingContext.class);
	
	private Converter converter;
 
    private Collection methods=new ArrayList();

	private Context context;
	
	public EvaluatingContext(Context context, Collection methods, Converter converter) throws EvaluationException {
		this.context=context;
		this.converter=converter;
		
		if (methods!=null) {
		    this.methods.addAll(methods);
		}
		
		try {
            this.methods.add(new MethodEntry(null, EvaluatingContext.class.getMethod("forEach", new Class[] {Object.class})));
        } catch (SecurityException e) {
			throw new EvaluationException(e);
        } catch (NoSuchMethodException e) {
			throw new EvaluationException(e);
        }
	}
	
	public static MultiResult forEach(Object param) throws EvaluationException {
		Collection values = new ArrayList();
	    populate(((SingleResult) param).getValue(), values);
		return new MultiResult(null, values, null);		            
	}
	
	public Object get(String expression) throws EvaluationException {
		logger.debug("New evaluator for expression: "+expression);
		ExpressionLexer lexer=new ExpressionLexer(new StringReader(expression));
		lexer.setTokenObjectClass(Token.class.getName());
		ExpressionRecognizer parser=new ExpressionRecognizer(lexer);
		parser.setASTNodeClass(AST.class.getName());
		try {
			parser.expressionList();
		} catch (RecognitionException e) {
			throw new EvaluationException(e);
		} catch (TokenStreamException e) {
			throw new EvaluationException(e);
		}
		
		List nodeList=new ArrayList();
		for (AST ast=(AST) parser.getAST().getFirstChild(); ast!=null; ast=(AST) ast.getNextSibling()) {
			nodeList.add(ast);
		}
		
		AST[] nodes = (AST[]) nodeList.toArray(new AST[nodeList.size()]);
		
		Collection ret=new ArrayList();
		for (int i=0; i<nodes.length; i++) {
			Result result = evaluate(null, nodes[i], context);
			if (result instanceof SingleResult) {
			    ret.add(((SingleResult) result).getValue());
			} else {
			    Object[] values=((MultiResult) result).getValues();
			    for (int j=0; j<values.length; j++) {
			        ret.add(values[j]);
			    }
			}
		}
		
		return ret.size()==1 ? ret.iterator().next() : ret;
	}
	
	
	/**
	 * @param o
	 * @param ast
	 * @param context
	 * @return evaluation result
	 * @throws EvaluationException
	 */
	private Result evaluate(Result res, AST ast, Context context) throws EvaluationException {
		logAst(ast);
        switch (ast.getType()) {
			case ExpressionTokenTypes.MINUS:
				return minus(res, ast, context);
			case ExpressionTokenTypes.PLUS:
				return plus(res, ast, context);
			case ExpressionTokenTypes.LNOT:
				return lnot(res, ast, context);
			case ExpressionTokenTypes.TYPECAST:
				return typecast(res, ast, context);
			case ExpressionTokenTypes.METHOD_CALL:
				return invoke(res, ast, context);
			case ExpressionTokenTypes.ARRAY_DECLARATOR:
				throw new EvaluationException("Handle it!");
			case ExpressionTokenTypes.INDEX_OP:
				return index(res, ast, context);
			case ExpressionTokenTypes.DOT:
				return dot(res, ast, context);
			case ExpressionTokenTypes.IDENT:
				Object obj = context.get(ast.getText());
			    return obj instanceof Result ? (Result) obj : new SingleResult(this.converter, null, obj);
			case ExpressionTokenTypes.LITERAL_true:
				return new SingleResult(this.converter, boolean.class, Boolean.TRUE);
			case ExpressionTokenTypes.LITERAL_false:
				return new SingleResult(this.converter, boolean.class, Boolean.FALSE);
			case ExpressionTokenTypes.LITERAL_null:
				return new SingleResult(this.converter, null, null);
			case ExpressionTokenTypes.NUM_INT:
				return new SingleResult(this.converter, int.class, new Integer(ast.getText()));
			case ExpressionTokenTypes.CHAR_LITERAL:
				return new SingleResult(this.converter, char.class, ast.getText().substring(0,1));
			case ExpressionTokenTypes.STRING_LITERAL:
			    String rawText=ast.getText();
				StringBuffer sb=new StringBuffer(rawText.substring(1, rawText.length()-1));
				for (int i=sb.indexOf("\\n"); i!=-1; i=sb.indexOf("\\n")) {
				    sb.replace(i, i+2, "\n");
				}
				for (int i=sb.indexOf("\\r"); i!=-1; i=sb.indexOf("\\r")) {
				    sb.replace(i, i+2, "\r");
				}
				for (int i=sb.indexOf("\\t"); i!=-1; i=sb.indexOf("\\t")) {
				    sb.replace(i, i+2, "\t");
				}
				return new SingleResult(this.converter, String.class, sb.toString());
			case ExpressionTokenTypes.NUM_FLOAT:
				return new SingleResult(this.converter, float.class, new Float(ast.getText()));
			case ExpressionTokenTypes.NUM_LONG:
				return new SingleResult(this.converter, long.class, new Long(ast.getText()));
			case ExpressionTokenTypes.NUM_DOUBLE:
				return new SingleResult(this.converter, double.class, new Double(ast.getText()));
			case ExpressionTokenTypes.LITERAL_boolean:
				return new SingleResult(this.converter, boolean.class, null);
			case ExpressionTokenTypes.LITERAL_byte:
				return new SingleResult(this.converter, byte.class, null);
			case ExpressionTokenTypes.LITERAL_char:
				return new SingleResult(this.converter, char.class, null);
			case ExpressionTokenTypes.LITERAL_short:
				return new SingleResult(this.converter, short.class, null);
			case ExpressionTokenTypes.LITERAL_float:
				return new SingleResult(this.converter, float.class, null);
			case ExpressionTokenTypes.LITERAL_long:
				return new SingleResult(this.converter, long.class, null);
			case ExpressionTokenTypes.LITERAL_double:
				return new SingleResult(this.converter, double.class, null);
			default:
				throw new EvaluationException(ast);			
		}
	}

	/**
	 * @param ast
	 */
	private static void logAst(AST ast) {
		logger.debug("Evaluating: ["+ExpressionRecognizer._tokenNames[ast.getType()]+"] "+ast.getLine()+":"+ast.getColumn()+" "+ast.toString());
	}

	/**
	 * @param res Current result
	 * @param ast Current node
	 * @param context Context
	 * @return evaluation result
	 * @throws EvaluationException
	 */
	private Result dot(Result res, AST ast, Context context) throws EvaluationException {
		Result result=evaluate(res, (AST) ast.getFirstChild(), context);
		String property = ast.getFirstChild().getNextSibling().getText();		
		if (result instanceof SingleResult) {
			Object value = ((SingleResult) result).getValue();
			if (value==null) {
				throw new EvaluationException(ast.getFirstChild().getText()+" is null");
			}
			
			Context ctx= value instanceof Context ? (Context) value : new BeanContext(value) {
                protected String translate(String name) {
                    return EvaluatingContext.this.translate(name);
                }
			};
			Object ret = ctx.get(property);
            return ret instanceof Result ? (Result) ret : new SingleResult(this.converter, null, ret);
		}
		
		Object[] values = ((MultiResult) result).getValues();
		
		Collection cres=new ArrayList();
		for (int i=0; i<values.length; i++) {
			Context ctx = values[i] instanceof Context ? (Context) values[i] : new BeanContext(values[i]) {
                protected String translate(String name) {
                    return EvaluatingContext.this.translate(name);
                }			    
			};
		    Object ret = ctx.get(property);
		    if (ret instanceof SingleResult) {
		        cres.add(((SingleResult) ret).getValue());
		    } else if (ret instanceof MultiResult) {
		        Object[] rets=((MultiResult) ret).getValues();
		        for (int j=0; j<rets.length; j++) {
		            cres.add(rets[j]);
		        }
		    } else {
		        cres.add(ret);
		    }
		}
		return new MultiResult(null, cres, converter);		    
	}

	/**
	 * @param res
	 * @param ast
	 * @param context
	 * @param converter
	 * @return
	 * @throws EvaluationException
	 */
	private Result index(Result res, AST ast, Context context) throws EvaluationException {
	    AST objectNode = (AST) ast.getFirstChild();
        Result result = evaluate(null, objectNode, context);
        if (result instanceof SingleResult) {
	        Object obj=((SingleResult) result).getValue();
		    if (obj==null) {
		        throw new EvaluationException("Value "+objectNode.getText()+" is null at "+objectNode.getLine()+":"+objectNode.getColumn());
		    }
		    
		    AST indexNode = (AST) objectNode.getNextSibling();
	        Result idr = evaluate(null, indexNode, context);
	        if (idr instanceof SingleResult) {
	            Object idx=((SingleResult) idr).getValue();
	            return new SingleResult(this.converter, null, index(ast, obj, indexNode, idx));
	        }
	        
	        Collection values=new ArrayList();
	        Object[] idxa=((MultiResult) idr).getValues();
	        for (int i=0; i<idxa.length; i++) {
	            values.add(index(ast, obj, indexNode, idxa[i]));
	        }
	        
	        return new MultiResult(null, values, converter);
        }
        
        Object[] objs=((MultiResult) result).getValues();
	    
	    AST indexNode = (AST) objectNode.getNextSibling();
        Collection values=new ArrayList();
        Result idr = evaluate(null, indexNode, context);
        if (idr instanceof SingleResult) {
            Object idx=((SingleResult) idr).getValue();
            for (int i=0; i<objs.length; i++) {
                values.add(index(ast, objs[i], indexNode, idx));
            }
            return new MultiResult(null, values, converter);
        }
        
        Object[] idxa=((MultiResult) idr).getValues();
        for (int j=0; j<objs.length; j++) {
	        for (int i=0; i<idxa.length; i++) {
	            values.add(index(ast, objs[j], indexNode, idxa[i]));
	        }
        }
        
        return new MultiResult(null, values, converter);
	}

	/**
     * @param ast
     * @param obj
     * @param indexNode
     * @param idx
     * @throws EvaluationException
     */
    private Object index(AST ast, Object obj, AST indexNode, Object idx) throws EvaluationException {
        if (idx==null) {
            throw new EvaluationException("Index "+indexNode.getText()+" is null at "+indexNode.getLine()+":"+indexNode.getColumn());
        }
        
        if (obj.getClass().isArray()) {	        
            return Array.get(obj, ((Number) converter.convert(idx, Number.class, null)).intValue());	        
        }
        
        if (obj instanceof Collection) {
            int index=((Number) converter.convert(idx, Number.class, null)).intValue();
            Iterator it=((Collection) obj).iterator();
            for (int i=0; it.hasNext(); i++) {
                Object next = it.next();
                if (i==index) {
                    return next;
                }
            }
            
            throw new EvaluationException("Index out of bounds: "+index+" at "+ast.getLine()+":"+ast.getColumn());
        }
        
        if (obj instanceof Iterator) {
            int index=((Number) converter.convert(idx, Number.class, null)).intValue();
            Iterator it=(Iterator) obj;
            for (int i=0; it.hasNext(); i++) {
                Object next = it.next();
                if (i==index) {
                    return next;
                }
            }
            
            throw new EvaluationException("Index out of bounds: "+index+" at "+ast.getLine()+":"+ast.getColumn());	        
        }
        
        if (obj instanceof Enumeration) {
            int index=((Number) converter.convert(idx, Number.class, null)).intValue();
            Enumeration enm=(Enumeration) obj;
            for (int i=0; enm.hasMoreElements(); i++) {
                Object nextElement = enm.nextElement();
                if (i==index) {
                    return nextElement;
                }
            }
            
            throw new EvaluationException("Index out of bounds: "+index+" at "+ast.getLine()+":"+ast.getColumn());	        
        }
        
        if (obj instanceof Context) {
            return ((Context) obj).get(idx.toString());
        }
        
        if (obj instanceof Map) {
            return ((Map) obj).get(idx);
        }
        
        throw new EvaluationException("Can't apply index operation to class "+obj.getClass().getName());
    }

    /**
	 * @param res
	 * @param ast
	 * @param context
	 * @param converter
	 * @return
	 * @throws EvaluationException
	 */
	private Result invoke(Result res, AST ast, Context context) throws EvaluationException {
		int paramCount = ast.getFirstChild().getNextSibling().getNumberOfChildren();
		AST nameNode = (AST) ast.getFirstChild();
		Object object;
		String methodName;
        switch (nameNode.getType()) {
			case ExpressionRecognizer.DOT:
			 	methodName = nameNode.getFirstChild().getNextSibling().getText();
				Result result = evaluate(res, (AST) nameNode.getFirstChild(), context);
				if (result instanceof MultiResult) {
				    Collection ret=new ArrayList();
				    Object[] values=((MultiResult) result).getValues();
				    for (int i=0; i<values.length; i++) {
				        ArrayList vCandidates=new ArrayList();
					    Method[] ma=values[i].getClass().getMethods();
					    for (int j=0; j<ma.length; j++) {
					        vCandidates.add(new MethodEntry(values[i], ma[j]));
					    }
				        Result ir = invokeInternal(res, context, paramCount, nameNode, vCandidates, methodName);
				        if (ir instanceof SingleResult) {
				            ret.add(((SingleResult) ir).getValue());
				        } else {
				            Object[] vv=((MultiResult) ir).getValues();
				            for (int k=0; k<vv.length; k++) {
				                ret.add(vv[k]);
				            }
				        }
				    }
				    return new MultiResult(null, ret, converter);
				}
				object = ((SingleResult) result).getValue();
				break;
			case ExpressionRecognizer.IDENT:
				object=context;
				methodName=nameNode.getText();
				break;
			default:
				throw new EvaluationException(nameNode);
		}
		
        ArrayList candidates=new ArrayList();
		if (object==null) {
		    candidates.addAll(methods);
		} else {
		    Method[] ma=object.getClass().getMethods();
		    for (int i=0; i<ma.length; i++) {
		        candidates.add(new MethodEntry(object, ma[i]));
		    }
		}
		
		return invokeInternal(res, context, paramCount, nameNode, candidates, methodName);
	}
	
	/**
     * @param res
     * @param context
     * @param paramCount
     * @param methods
     * @param nameNode
     * @param object
     * @param methodName
     * @return
     * @throws EvaluationException
     */
    private Result invokeInternal(Result res, Context context, int paramCount, AST nameNode, ArrayList methods, String methodName) throws EvaluationException {
        Iterator it=methods.iterator();
        while (it.hasNext()) {
            MethodEntry me=(MethodEntry) it.next();
            if (!me.name.equals(methodName) || me.method.getParameterTypes().length!=paramCount) {
                it.remove();
            }
        }
        
		if (methods.isEmpty()) {
			throw new EvaluationException("No appropriate method '"+methodName+"'");
		}

		Result[] params=new Result[paramCount];
		int idx=0;
		boolean multiResult=false;
		for (AST paramNode=(AST) nameNode.getNextSibling().getFirstChild(); paramNode!=null; paramNode=(AST) paramNode.getNextSibling(), idx++) {
			params[idx]=evaluate(res, paramNode, context);
			if (params[idx] instanceof MultiResult) {
			    multiResult=true;
			}
			
			if (params[idx].getType()!=null) {
				it=methods.iterator();
				while (it.hasNext()) {
		            MethodEntry me=(MethodEntry) it.next();
					if (!me.method.getParameterTypes()[idx].isAssignableFrom(params[idx].getType())) {
						it.remove();
					}
				}
			}
		}
		
		it=methods.iterator();
		Z: while (it.hasNext()) {
		    MethodEntry me=(MethodEntry) it.next();
		    Iterator jt=methods.iterator();
		    while (jt.hasNext()) {
		        switch (((MethodEntry) jt.next()).isMoreSpecific(me)) {
		        	case 1:
		        	    it.remove();
		        	    break Z;
		        	case -1: 
		        	    jt.remove();
		        }
		    }
		}
		
		// Finding proper method

		if (methods.isEmpty()) {
			throw new EvaluationException("No appropriate method '"+methodName+"'");
		}

		if (methods.size()>1) {
			StringBuffer msg=new StringBuffer("Ambiguous method '"+methodName+"': ");
			it=methods.iterator();
			while (it.hasNext()) {
				msg.append("\n\t");
				msg.append(((MethodEntry) it.next()).method);
			}
			
			throw new EvaluationException(msg.toString());
		}
		
		final MethodEntry methodEntry=(MethodEntry) methods.get(0);
		
		if (multiResult) {
		    Collection ret=new ArrayList();
		    Collection args=new ArrayList();
		    args.add(new Object[params.length]);
		    for (int i=0; i<params.length; i++) {
		        args=setArgs(args, i, params[i], methodEntry.method.getParameterTypes()[i]);
		    }
		    return new MultiResult(methodEntry.method.getReturnType(), ret, converter);
		}
		
		Object[] args=new Object[params.length];
		for (int i=0; i<params.length; i++) {
			args[i]=converter.convert(((SingleResult) params[i]).getValue(), methodEntry.method.getParameterTypes()[i], null);
		}

		return new SingleResult(this.converter, methodEntry.method.getReturnType(), methodEntry.invoke(args));
    }

    private Collection setArgs(Collection args, int idx, Result arg, Class paramType) {
	    if (arg instanceof SingleResult) {
	        Iterator it=args.iterator();
	        while (it.hasNext()) {
	            ((Object[]) it.next())[idx]=converter.convert(((SingleResult) arg).getValue(), paramType, null);
	        }
	        return args;
	    }

	    Collection ret=new ArrayList();
	    Object[] values=((MultiResult) arg).getValues();
        Iterator it=args.iterator();
        while (it.hasNext()) {
            Object[] objs = (Object[]) it.next();
            for (int i=0; i<values.length; i++) {
                Object[] cobjs=(Object[]) objs.clone();
                cobjs[idx]=converter.convert(values[i], paramType, null);
                ret.add(cobjs);
	        }	        
	    }
	    return ret;	    	    
	}

	/**
     * @param object
     * @param values
	 * @throws EvaluationException
     */
    private static void populate(Object object, Collection values) throws EvaluationException {
        if (object.getClass().isArray()) {
            for (int i=0, j=Array.getLength(object); i<j; i++) {
                values.add(Array.get(object, i));
            }
        } else if (object instanceof Collection) {
            values.addAll((Collection) object);
        } else if (object instanceof Map) {
            values.addAll(((Map) object).entrySet());
        } else if (object instanceof Iterator) {
            while (((Iterator) object).hasNext()) {
                values.add(((Iterator) object).next());
            }
        } else if (object instanceof Enumeration) {
            while (((Enumeration) object).hasMoreElements()) {
                values.add(((Enumeration) object).nextElement());
            }
        } else {
            throw new EvaluationException("forEach() is not applicable for "+object.getClass());
        }
    }

    /**
	 * @param res
	 * @param ast
	 * @param context
	 * @return
	 */
	private Result typecast(Result res, AST ast, Context context) {
		ast.print(ExpressionRecognizer._tokenNames, false);
		throw new UnsupportedOperationException("Not yet implemented");
	}

	/**
	 * @param res
	 * @param ast
	 * @param context
	 * @return
	 */
	private Result lnot(Result res, AST ast, Context context) {
		ast.print(ExpressionRecognizer._tokenNames, false);
		throw new UnsupportedOperationException("Not yet implemented");
	}

	/**
	 * @param res
	 * @param ast
	 * @param context
	 * @return
	 */
	private Result plus(Result res, AST ast, Context context) {
		ast.print(ExpressionRecognizer._tokenNames, false);
		throw new UnsupportedOperationException("Not yet implemented");
	}

	/**
	 * @param res
	 * @param ast
	 * @param context
	 * @return
	 */
	private Result minus(Result res, AST ast, Context context) {
		ast.print(ExpressionRecognizer._tokenNames, false);
		throw new UnsupportedOperationException("Not yet implemented");
	}

	private String identifier(AST ast) throws EvaluationException {
		switch (ast.getType()) {
			case ExpressionTokenTypes.IDENT:
				return ast.getText();
			case ExpressionTokenTypes.DOT:
				return identifier((AST) ast.getFirstChild())+"."+identifier((AST) ast.getFirstChild().getNextSibling());
			default:
				throw new EvaluationException("Unexpected node type: "+ExpressionRecognizer._tokenNames[ast.getType()]);
		}
	}
		
	/**
	 * Translates "indexed" property name.
	 * By default replaces '_' with ' '
	 * @param name
	 * @return
	 */
	protected String translate(String name) {
	    return name.replace('_', ' ');
	}
}