EvaluatingFilterWriter.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.FilterWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.apache.log4j.Logger;

import biz.hammurapi.config.Context;
import biz.hammurapi.convert.Converter;


/**
 * @author Pavel Vlasov
 * @version $Revision$
 */
public class EvaluatingFilterWriter extends FilterWriter {
    private int mode;

    private Context context;

    private Converter converter;

    private static final Logger logger = Logger.getLogger(EvaluatingFilterWriter.class);

	private Set keySet;

    public EvaluatingFilterWriter(
            Writer out, 
            int mode,
            Context context, 
            Converter converter) {
        	this(out,mode,context, converter,new HashSet());
    }
    
    private EvaluatingFilterWriter(
            Writer out, 
            int mode,
            Context context, 
            Converter converter,
			Set keySet) {
        super(out);
        this.mode = mode;
        this.context = context;
        this.converter = converter;
        this.keySet=keySet;
    }

    private int lastChar;

    private StringBuffer expressionBuffer;

    private static final int STATE_NORMAL = 0;

    private static final int STATE_DOLLAR = 1;

    private static final int STATE_EXPRESSION = 2;

    private static final int STATE_QUOTE = 3;

    public static final int MODE_LENIENT = 0;

    public static final int MODE_MESSAGE = 1;

    public static final int MODE_STRICT = 2;

    private int state = STATE_NORMAL;

    public void write(int c) throws IOException {
        switch (c) {
	        case '$':
	            switch (state) {
		            case STATE_NORMAL:
		                state = STATE_DOLLAR;
		                break;
		            case STATE_DOLLAR:
		                state = STATE_NORMAL;
		                out.write(c);
//		                out.write(b);

		                break;
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        case '{':
	            switch (state) {
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state = STATE_EXPRESSION;
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        case '}':
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state = STATE_NORMAL;
		                out.write(c);
		            case STATE_EXPRESSION:
		                state = STATE_NORMAL;
		                if (expressionBuffer == null) {
		                    out.write('$');
		                    out.write('{');
		                    out.write('}');
		                } else {
		                    String expression = expressionBuffer.toString();
		                    expressionBuffer = null;
		                    try {
		                        Evaluator evaluator = new Evaluator(expression, null, converter);
		                        Iterator it = evaluator.evaluate(context).iterator();
		                        while (it.hasNext()) {
		                            Object object = it.next();
		                            if (object == null) {
		                                out.write("(null)");
		                            } else {
		                                out.write(object.toString());
		                                if (it.hasNext()) {
		                                    out.write(' ');
		                                }
		                            }
		                        }		
		                    } catch (EvaluationException e) {
		                        switch (mode) {
			                        case MODE_LENIENT:
			                            logger.warn("Evaluation failed for: " + expression,  e);
			                            out.write("${"+expression+"}");
			                            break;
			                        case MODE_MESSAGE:
			                            logger.warn("Evaluation failed for: " + expression,  e);
			                            out.write(" *** Evaluation failed for: " + expression+" *** ");
			                            break;	                            
			                        case MODE_STRICT:
			                            logger.error("Evaluation failed for: " + expression,  e);	                            
			                            throw new IOException("Evaluation failed for: '" + expression+"' - " + e);
		                            default:
		                                throw new IOException("Invalid mode: "+mode);
		                        }
		                    }
		                }
		                break;
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
		        }
	            break;
	        case '"':
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state=STATE_NORMAL;
		                out.write(c);
		                break;
		            case STATE_EXPRESSION:
		                state=STATE_QUOTE;
		                toBuffer(c);
		                break;
		            case STATE_QUOTE:
		                if (lastChar!='\\') {
		                    state=STATE_EXPRESSION;
		                }
	                    toBuffer(c);
	                    break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
	            break;
	        default:
	            switch (state) {
		            case STATE_NORMAL:
		                out.write(c);
		                break;
		            case STATE_DOLLAR:
		                state=STATE_NORMAL;
		                out.write(c);
		                break;
		            case STATE_EXPRESSION:
		            case STATE_QUOTE:
		                toBuffer(c);
		                break;
		            default:
		                throw new IOException("Invalid lexer state: " + state);
	            }
        }
        lastChar = c;
    }

    /**
     * @param b
     */
    private void toBuffer(int b) {
        if (expressionBuffer == null) {
            expressionBuffer = new StringBuffer();
        }
        expressionBuffer.append((char) b);
    }

    public void close() throws IOException {
        if (state == STATE_DOLLAR) {
            out.write('$');
        } else if (state == STATE_EXPRESSION || state == STATE_QUOTE) {
            out.write('$');
            out.write('{');
        }

        if (expressionBuffer != null) {
            out.write(expressionBuffer.toString());
            expressionBuffer = null;
        }
        out.close();
        super.close();
    }

    public void write(char[] cbuf, int off, int len) throws IOException {
        for (int i=0; i<len; i++) {
            write(cbuf[i+off]);
        }
    }
    
    public void write(String str, int off, int len) throws IOException {
        for (int i=0; i<len; i++) {
            write(str.charAt(i+off));
        }
    }
}