| gvSIG desktop 1

/**

 * 

 */

package org.gvsig.data.datastores.vectorial.file.shp;

import java.io.File;

import java.util.Date;

import java.util.List;

import junit.framework.TestCase;

import org.apache.log4j.FileAppender;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;

import org.apache.log4j.PatternLayout;

import org.apache.log4j.PropertyConfigurator;

import org.gvsig.compatible.StringUtil;

import org.gvsig.data.CloseException;

import org.gvsig.data.DataManager;

import org.gvsig.data.DataStoreParameters;

import org.gvsig.data.InitializeException;

import org.gvsig.data.OpenException;

import org.gvsig.data.ReadException;

import org.gvsig.data.vectorial.AttributeDescriptor;

import org.gvsig.data.vectorial.DefaultFeatureType;

import org.gvsig.data.vectorial.FeatureCollection;

import org.gvsig.data.vectorial.FeatureType;

import org.gvsig.data.vectorial.filter.FilterFactory2Impl;

import org.opengis.filter.Filter;

import org.opengis.filter.FilterFactory2;

import org.opengis.filter.expression.Expression;

import org.opengis.filter.sort.SortBy;

/**

 * @author jsanz

 *

 */

public class TestLevenshteinFilter extends TestCase {

        static Logger log = null;

        static File TEST_SHP = ResourceReader.getResourceFile("testdata", "albania.shp");

        SHPStore store;

        public TestLevenshteinFilter() {

                super();

        }

        public TestLevenshteinFilter(String name) {

                super(name);

                // TODO Auto-generated constructor stub

        }

        /**

         * @throws java.lang.Exception

         */

        protected void setUp() throws Exception {

                if (log==null){

                        Date now = new Date(System.currentTimeMillis());

                        String nowstr = now.toString();

                        nowstr = StringUtil.replaceAllString(nowstr, " ", "_");

                        nowstr = StringUtil.replaceAllString(nowstr, ":", "_") + ".txt";

                        String outlogpath = "";

                        outlogpath = ResourceReader.getResourceFile("testdata", "filter_test_" + nowstr).getAbsolutePath();

                        System.out.println("Log file: " + outlogpath);

                        try {

                            PatternLayout l = new PatternLayout("%5p [%t] - %m%n");

                            FileAppender fa = new FileAppender(l, outlogpath, false);

                            // ConsoleAppender ca = new ConsoleAppender(l);

                            Logger.getRootLogger().setLevel(Level.DEBUG);

                            Logger.getRootLogger().addAppender(fa);

                            // Logger.getRootLogger().addAppender(ca);

                        } catch (Exception ex) {

                                System.err.println("Error while initializing log4j: " + ex.getMessage());

                        }

                        log = Logger.getLogger(TestLevenshteinFilter.class);

                }

                Register.selfRegister();

                DataManager manager = DataManager.getManager();

                SHPStoreParameters parameters = null;

                parameters=(SHPStoreParameters)manager.createDataStoreParameters(SHPStore.DATASTORE_NAME);

                parameters.setFile(TEST_SHP);

                try {

                        store= (SHPStore)manager.createDataStore((DataStoreParameters) parameters);

                } catch (InitializeException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        /**

         * @throws java.lang.Exception

         */

        protected void tearDown() throws Exception {

        }

        public void testGetFeatureTypes(){

                log.info("-----------testGetFeatureTypes-----------");

                List types = store.getFeatureTypes();

                assertEquals(1, types.size());

                DefaultFeatureType ftype = (DefaultFeatureType) types.get(0);

                log.info("Type with " + ftype.size() + " attributes");

                Object att =  ftype.get("ASCIINAME");

                assertNotNull(att);

                assertTrue(att instanceof AttributeDescriptor);

                AttributeDescriptor ad = (AttributeDescriptor) att;

                assertEquals(AttributeDescriptor.TYPE_STRING, ad.getDataType());

                log.info("-----------testGetFeatureTypes-----------");

        }

        public void testLevenshteinFilter(){

                log.info("-----------testLevenshteinFilter-----------");

//                long t1 = System.currentTimeMillis();

                FilterFactory2 fact = new FilterFactory2Impl();

                Expression exp1 = fact.property("ASCIINAME");

                //Expression exp2 = fact.literal("Okshtunit");

                Filter filter = fact.like(exp1, "%Okshtunit%");

                //Filter filter = fact.like(exp2, "%Okshtunit%");

//                Filter filter = fact.equals(exp1, exp2);

                int results = testshp(filter, null);

//                log.info("Search retrieved in " + (System.currentTimeMillis() - t1) + " msecs");

                assertEquals(2,results);

                log.info("-----------testLevenshteinFilter-----------");

        }

        private int testshp(Filter filter, SortBy[] order){

                try {

                        store.open();

                } catch (OpenException e2) {

                        // TODO Auto-generated catch block

                        e2.printStackTrace();

                }

                FeatureType ft=store.getDefaultFeatureType();

                FeatureCollection featureCollection=null;

//                try{

//                        StringWriter out = new StringWriter();

//                        FilterToSQL converter = new FilterToSQL(out);

//                        converter.encode(filter);

//                        log.info(out.toString());

//                } catch (FilterToSQLException e){

//                        e.printStackTrace();

//                }

                try {

                        long t1 = System.currentTimeMillis();

                        featureCollection = (FeatureCollection)store.getDataCollection(ft,filter,order);

                        log.info("Search retrieved in " + (System.currentTimeMillis() - t1) + " msecs");

                } catch (ReadException e1) {

                        // TODO Auto-generated catch block

                        e1.printStackTrace();

                }

//                Iterator iter = featureCollection.iterator();

//                Iterator titlesIt=ft.iterator();

//                log.info("ID");

//                while (titlesIt.hasNext()) {

//                        FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) titlesIt.next();

//                        log.info("\t"+ descriptor.getName() + "(" + descriptor.getDataType().substring(0,3)+")");

//                }

//                System.out.println("");

//                while (iter.hasNext()) {

//                        Feature feature = (Feature)iter.next();

//                        log.info(feature.getID().toString());

//                        //System.out.println("SHP Feature ------------------- ");

//                        Iterator iterator=ft.iterator();

//                        while (iterator.hasNext()) {

//                                FeatureAttributeDescriptor descriptor = (FeatureAttributeDescriptor) iterator.next();

//                                int i=descriptor.ordinal();

//                                String type=descriptor.getDataType();

//                                //System.out.println("****** "+ descriptor.getName());

//                                if (type.equals(FeatureAttributeDescriptor.TYPE_BOOLEAN)){

//                                        log.info("\t"+ feature.getBoolean(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_BYTE)){

//                                        log.info("\t"+ feature.getByte(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_DATE)){

//                                        try{

//                                                log.info("\t"+ feature.getDate(i));

//                                        } catch (Exception e){

//                                                

//                                        }

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_DOUBLE)){

//                                        log.info("\t"+ feature.getDouble(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_FLOAT)){

//                                        log.info("\t"+ feature.getFloat(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_INT)){

//                                        log.info("\t"+ feature.getInt(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_LONG)){

//                                        log.info("\t"+ feature.getLong(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_STRING)){

//                                        log.info("\t"+ feature.getString(i));

//                                }else if (type.equals(FeatureAttributeDescriptor.TYPE_GEOMETRY)){

//

//                                        log.info("\tGeometry");

//                                }

//                        }

//                        log.info("");

//                }

//                iter=null;

                long t1 = System.currentTimeMillis();

                int numFeat = featureCollection.size();

                log.info("Count retrieved in " + (System.currentTimeMillis() - t1) + " msecs");

                featureCollection.dispose();

                try {

                        store.close();

                        store.dispose();

                } catch (CloseException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                return numFeat;

        }

}