Index: topia/src/java/org/codelutin/topia/TopiaMapQueryHelper.java
diff -u /dev/null topia/src/java/org/codelutin/topia/TopiaMapQueryHelper.java:1.1
--- /dev/null	Tue Jun 14 17:03:15 2005
+++ topia/src/java/org/codelutin/topia/TopiaMapQueryHelper.java	Tue Jun 14 17:03:10 2005
@@ -0,0 +1,402 @@
+/* *##%
+* Copyright (C) 2002, 2003, 2004, 2005 Code Lutin,
+*    Cédric Pineau, Benjamin Poussin,
+*
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU 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 General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*##%*/
+
+/* *
+* TopiaMapQueryHelper.java
+*
+* Created: 13 juin 2005
+*
+* @author Arnaud Thimel <thimel@codelutin.com>
+* @version $Revision: 1.1 $
+*/
+
+
+package org.codelutin.topia;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Map;
+
+import org.codelutin.queryparser.Constraint;
+import org.codelutin.queryparser.DefaultQueryVisitorUnsupportedOperation;
+import org.codelutin.queryparser.FieldPath;
+import org.codelutin.queryparser.From;
+import org.codelutin.queryparser.OrderBy;
+import org.codelutin.queryparser.QMark;
+import org.codelutin.queryparser.Query;
+import org.codelutin.queryparser.QueryHelper;
+import org.codelutin.queryparser.QueryHelperException;
+import org.codelutin.queryparser.Select;
+import org.codelutin.queryparser.Where;
+
+import bsh.EvalError;
+import bsh.Interpreter;
+
+
+public class TopiaMapQueryHelper extends QueryHelper{
+
+    protected TopiaMapQueryBuilder queryBuilder;
+    protected Map dataMap;
+    protected Interpreter interpreter;
+    
+    public TopiaMapQueryHelper(Map datas) {
+        dataMap = datas;
+    }
+    
+    public void setQuery(Query query) {
+        super.setQuery(query);
+        queryBuilder = null;
+        HashMap fields = getQuery().getSelect().getFields();
+        if(fields.size() != 1)
+            throw new IllegalArgumentException("Select statement must have one field only. "+fields);
+    }
+
+    /* (non-Javadoc)
+     * @see org.codelutin.queryparser.QueryHelper#execute()
+     */
+    public Collection execute() throws QueryHelperException {
+
+        if (queryBuilder == null) { //Préparation de la requete pour BSH
+            queryBuilder = new TopiaMapQueryBuilder();
+            getQuery().visit(queryBuilder);
+            System.out.println(queryBuilder.getClassName());
+            System.out.println(queryBuilder.getFrom());
+            System.out.println(queryBuilder.getFilter());
+            interpreter = new Interpreter();
+            try {
+                for(int i=0; i<args.size(); i++){
+                    interpreter.set("$" + (i+1), args.get(i));
+                }
+            } catch (EvalError e) {
+                e.printStackTrace();
+            }
+            generateToObjectForBSH(interpreter);
+        }
+        
+
+        Collection result = new ArrayList();
+        for (Iterator it = dataMap.values().iterator(); it.hasNext(); ) {
+            Object o = it.next();
+            if (evalTrue(o, queryBuilder.getFilter(), interpreter))
+                result.add(o);
+        }
+        
+        //TODO Arno : Tri des résultats - orderBy
+        
+        //TODO Arno : renvoi uniquement des fieldPath
+
+        return result;
+    }
+
+    private void generateToObjectForBSH(Interpreter interpreter) {
+        try {
+            interpreter.eval("toObject(boolean value) {new Boolean(value);}");
+            interpreter.eval("toObject(char value) {new String(\"\" + value);}");
+            //Tout nombre est converti en Double
+            interpreter.eval("toObject(double value) {new Double(value);}");
+            interpreter.eval("toObject(Object o) {o;}");
+            interpreter.eval("equals(o1, o2) {if ((toObject(o1) instanceof Number) && (toObject(o2) instanceof Number)) return (toObject(o1).doubleValue() == toObject(o2).doubleValue()); else return toObject(o1).equals(toObject(o2));}");
+        } catch (EvalError e) {
+            e.printStackTrace();
+        }
+    }
+    
+    protected Object toObject(float value) {
+        return new Double(value);
+    }
+
+    protected boolean evalTrue(Object o, String filter, Interpreter interpreter) {
+        //System.out.println(filter);
+        Boolean result = new Boolean(false);
+        try {
+            interpreter.set("target", o);
+            result = (Boolean)interpreter.eval(filter);
+        } catch (EvalError e) {
+            e.printStackTrace();
+        }
+        return result.booleanValue();
+    }
+    
+    public class TopiaMapQueryBuilder extends DefaultQueryVisitorUnsupportedOperation {
+        
+        public String getClassName() {
+            return className;
+        }
+        public String getFieldName() {
+            return fieldName;
+        }
+        public String getFilter() {
+            return "(target instanceof " + from + ") && " + filter;
+        }
+        public String getFrom() {
+            return from;
+        }
+        protected String className;
+        protected String fieldName;
+        protected String from;
+        protected String filter = "";
+
+        protected Collection argCollection = new LinkedList();
+
+        protected int argCount = 1;
+        
+        protected Query query;
+        
+        public void visitFrom(From from) {
+            //Nothing more than visitFromSource
+        }
+
+        public void visitFromSource(From from, String field, String alias) {
+            // TODO Arno : Auto-generated method stub
+            this.from = field;
+        }
+        
+        
+        public void visitOrderBy(OrderBy orderBy) {
+            // TODO Arno : Auto-generated method stub
+        }
+        public void visitOrderByField(OrderBy orderBy, FieldPath field,
+                boolean asc) {
+            // TODO Arno : Auto-generated method stub
+        }
+        
+        
+        public void visitQuery(Query query) {
+            this.query = query;
+        }
+        
+        
+        public void visitSelect(Select select) {
+            //Rien de plus que visitSelectField
+        }
+        public void visitSelectAvg(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectAvg\" " + select);
+        }
+        public void visitSelectCount(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectCount\" " + select);
+        }
+        public void visitSelectDistinct(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectDistinct\" " + select);
+        }
+        public void visitSelectField(Select select, FieldPath field,
+                String alias) {
+            this.className = field.getField();
+            /*//TODO Arno
+            className = field.getField();
+            int pos = query.getFrom().startsWithSourceOrAlias(className);
+            if(pos != -1 && pos != className.length()){
+                fieldName = className.substring(pos+1);
+                className = className.substring(0, pos);
+            }
+            className = query.getFrom().getSource(className);
+            */
+        }
+        public void visitSelectLimit(Select select, int first, int last) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectLimit\" " + select + " - " + first + " - " + last);
+        }
+        public void visitSelectMax(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectMax\" " + select);
+        }
+        public void visitSelectMin(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectMin\" " + select);
+        }
+        public void visitSelectSum(Select select) {
+            // TODO Arno : Auto-generated method stub
+            System.out.println("\"selectSum\" " + select);
+        }
+        
+        //Visite récursivement l'opérande spécifiée
+        protected void visitOperand(Object op){
+            //System.out.println(op.getClass().getName() + " : " + op);
+            if (op instanceof Constraint) {
+                ((Constraint)op).visit(this);
+            } else if(op == null) {
+                filter += " null";
+            } else if(op instanceof String) {
+                filter += " \""+op.toString()+"\"";
+            } else if(op instanceof QMark) {
+                filter += " $" + (argCount++);
+            } else if(op instanceof FieldPath) {
+                FieldPath field = (FieldPath)op;
+                String path = field.getField();
+                String source = query.getFrom().getSource(field);
+                if (source.equals("")) {
+                    source = className;
+                }
+                if (className.equals(source)) {
+                    path = query.getFrom().getField(field);
+                } else {
+                    // Sans doute faire plusieurs requetes pour pouvoir supporter
+                    // plusieurs sources et faire des jointure entre elle.
+                    throw new UnsupportedOperationException("Only one source can be used");
+                }
+                filter += "target." + path;
+            } else if(op instanceof Number) {
+                filter += op.toString();
+            } else if(op instanceof Boolean) {
+                filter += op.toString();
+            } else if(op instanceof Collection) {
+                argCollection.add(op);
+                filter += "argCollection" + argCollection.size();
+            } else {
+                throw new UnsupportedOperationException("This operand is not supported: "+op.getClass().getName());
+            }
+
+        }
+
+        
+        public void visitWhere(Where where) {
+            //Voir les visitWhere spécifiques...
+        }
+        public void visitWhereAnd(Constraint constraint, Object op1, Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " && ";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereEqual(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(equals(";
+            visitOperand(op1);
+            filter += ", ";
+            visitOperand(op2);
+            filter += "))";
+        }
+        public void visitWhereNotEqual(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(!equals(";
+            visitOperand(op1);
+            filter += ", ";
+            visitOperand(op2);
+            filter += "))";
+        }
+        public void visitWhereGreater(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " > ";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereGreaterOrEqual(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " >= ";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereIn(Constraint constraint, Object op1, Object op2) {
+            filter += "(";
+            visitOperand(op2);
+            filter += ".contains(";
+            visitOperand(op1);
+            filter += "))";
+        }
+        public void visitWhereLike(Constraint constraint, Object op1, Object op2) {
+            //TODO Arno : A verif ! % => .*?  (to be used with matches(...))
+            if(op2 instanceof String){
+                String likeValue = (String)op2;
+                if(likeValue.startsWith("%")){
+                    visitOperand(op1);
+                    filter += ".endsWith(";
+                    op2 = likeValue.substring(1);
+                }else if(likeValue.endsWith("%")){
+                    visitOperand(op1);
+                    filter += ".startsWith(";
+                    op2 = likeValue.substring(0, likeValue.length() - 1);
+                }
+            }else{
+                filter += "(";
+                visitOperand(op1);
+                filter += "==";
+            }
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereNot(Constraint constraint, Object op2) {
+            filter += "(!";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereNotIn(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(!";
+            visitOperand(op2);
+            filter += ".contains(";
+            visitOperand(op1);
+            filter += "))";
+        }
+        public void visitWhereNotLike(Constraint constraint, Object op1,
+                Object op2) {
+            //TODO Arno : A verif !
+            String likeValue = (String)op2;
+            if(likeValue.startsWith("%")){
+                filter += "!";
+                visitOperand(op1);
+                filter += ".endsWith(";
+            }else if(likeValue.endsWith("%")){
+                filter += "!";
+                visitOperand(op1);
+                filter += ".startsWith(";
+            }else{
+                filter += "(";
+                visitOperand(op1);
+                filter += "!=";
+            }
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereOr(Constraint constraint, Object op1, Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " || ";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereSmaller(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " < ";
+            visitOperand(op2);
+            filter += ")";
+        }
+        public void visitWhereSmallerOrEqual(Constraint constraint, Object op1,
+                Object op2) {
+            filter += "(";
+            visitOperand(op1);
+            filter += " <= ";
+            visitOperand(op2);
+            filter += ")";
+        }
+
+    }
+}