Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.data.feature.expressionevaluator.sqljep;

import junit.framework.TestCase;

import org.gvsig.fmap.data.feature.AttributeDescriptor;

import org.gvsig.fmap.data.feature.DefaultFeatureType;

import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.data.feature.FeatureType;

import org.gvsig.fmap.data.feature.IsNotAttributeSettingException;

import org.gvsig.fmap.geom.Geometry;

import org.medfoster.sqljep.ASTArray;

import org.medfoster.sqljep.ASTFunNode;

import org.medfoster.sqljep.ASTStart;

import org.medfoster.sqljep.ASTVarNode;

import org.medfoster.sqljep.Node;

import org.medfoster.sqljep.ParseException;

import org.medfoster.sqljep.SimpleNode;

public class VisitTreeTest extends TestCase {

        public void testParser() {

                FeatureType fType = newFeatureType();

                MyParser p = new MyParser(

                                "ID=1 and intersects(GeomFromText('xxx','23030'),GEOMETRY)",

                                fType);

                try {

                        p.myParseExpression();

                        assertTrue(p.isValid());

                        Node node = p.getTopNode();

                        System.out.println(node);

                        iterate(node);

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

        private void iterate(Node node) {

                if (node == null) {

                        return;

                }

                for (int i = 0; i < node.jjtGetNumChildren(); i++) {

                        Node n = node.jjtGetChild(i);

                        System.out.println(n.toString());

                        iterate(n);

                }

        }

        private FeatureType newFeatureType() {

                DefaultFeatureType fType = new DefaultFeatureType();

                try {

                        AttributeDescriptor descriptorID = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorID.loading();

                        descriptorID.setType(FeatureAttributeDescriptor.TYPE_INT);

                        descriptorID.setName("ID");

                        descriptorID.setDefaultValue(new Integer(0));

                        descriptorID.stopLoading();

                        fType.add(descriptorID);

                        AttributeDescriptor descriptorShape = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorShape.loading();

                        descriptorShape.setType(FeatureAttributeDescriptor.TYPE_GEOMETRY);

                        descriptorShape.setName("GEOMETRY");

                        descriptorShape.setDefaultValue(null);

                        descriptorShape.stopLoading();

                        fType.add(descriptorShape);

                        fType.setDefaultGeometry("GEOMETRY");

                        AttributeDescriptor descriptorEntity = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorEntity.loading();

                        descriptorEntity.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorEntity.setName("Entity");

                        descriptorEntity.setDefaultValue("Entity");

                        descriptorEntity.stopLoading();

                        fType.add(descriptorEntity);

                        AttributeDescriptor descriptorLayer = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorLayer.loading();

                        descriptorLayer.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorLayer.setName("Layer");

                        descriptorLayer.setDefaultValue("default");

                        descriptorLayer.stopLoading();

                        fType.add(descriptorLayer);

                        AttributeDescriptor descriptorColor = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorColor.loading();

                        descriptorColor.setType(FeatureAttributeDescriptor.TYPE_INT);

                        descriptorColor.setName("Color");

                        descriptorColor.setDefaultValue(new Integer(0));

                        descriptorColor.stopLoading();

                        fType.add(descriptorColor);

                        AttributeDescriptor descriptorElevation = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorElevation.loading();

                        descriptorElevation.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorElevation.setName("Elevation");

                        descriptorElevation.setDefaultValue(new Double(0));

                        descriptorElevation.stopLoading();

                        fType.add(descriptorElevation);

                        AttributeDescriptor descriptorThickness = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorThickness.loading();

                        descriptorThickness.setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorThickness.setName("Thickness");

                        descriptorThickness.setDefaultValue(new Double(0));

                        descriptorThickness.stopLoading();

                        fType.add(descriptorThickness);

                        AttributeDescriptor descriptorText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorText.loading();

                        descriptorText.setType(FeatureAttributeDescriptor.TYPE_STRING);

                        descriptorText.setName("Text");

                        descriptorText.setDefaultValue("");

                        descriptorText.stopLoading();

                        fType.add(descriptorText);

                        AttributeDescriptor descriptorHeightText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorHeightText.loading();

                        descriptorHeightText.setType(FeatureAttributeDescriptor.TYPE_FLOAT);

                        descriptorHeightText.setName("HeightText");

                        descriptorHeightText.setDefaultValue(new Float(10));

                        descriptorHeightText.stopLoading();

                        fType.add(descriptorHeightText);

                        AttributeDescriptor descriptorRotationText = (AttributeDescriptor) fType

                                        .createAttributeDescriptor();

                        descriptorRotationText.loading();

                        descriptorRotationText

                                        .setType(FeatureAttributeDescriptor.TYPE_DOUBLE);

                        descriptorRotationText.setName("Rotation");

                        descriptorRotationText.setDefaultValue(new Double(10));

                        descriptorRotationText.stopLoading();

                        fType.add(descriptorRotationText);

                        fType.setDefaultGeometry("GEOMETRY");

                        fType.setGeometryTypes(new int[] { Geometry.TYPES.GEOMETRY });

                } catch (IsNotAttributeSettingException e) {

                        e.printStackTrace();

                }

                return fType;

        }

        class PVisitor /* implements ParserVisitor */{

                public Object visit(SimpleNode arg0, Object arg1) throws ParseException {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Object visit(ASTStart arg0, Object arg1) throws ParseException {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Object visit(ASTFunNode arg0, Object arg1) throws ParseException {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Object visit(ASTVarNode arg0, Object arg1) throws ParseException {

                        // TODO Auto-generated method stub

                        return null;

                }

                public Object visit(ASTArray arg0, Object arg1) throws ParseException {

                        // TODO Auto-generated method stub

                        return null;

                }

                /*

                 * public Object visit(ASTConstant arg0, Object arg1) throws

                 * ParseException { // TODO Auto-generated method stub return null; }

                 */

        }

        private class MyParser extends ExpressionEvaluator {

                public MyParser(String expression, FeatureType featureType) {

                        super(expression, featureType);

                }

                public void myParseExpression() throws ParseException {

                        this.parseExpression();

                }

        }

}