Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap.layers;

import java.io.File;

import java.io.IOException;

import java.sql.SQLException;

import java.sql.Types;

import java.util.Hashtable;

import java.util.TreeMap;

import org.apache.log4j.Logger;

import org.cresques.cts.IProjection;

import org.cresques.io.data.RasterBuf;

import org.cresques.px.Extent;

import org.geotools.geometry.coordinatesequence.InPlaceCoordinateSequenceTransformer;

import com.hardcode.driverManager.Driver;

import com.hardcode.driverManager.DriverLoadException;

import com.hardcode.driverManager.DriverManager;

import com.hardcode.driverManager.IDelayedDriver;

import com.hardcode.driverManager.WriterManager;

import com.hardcode.gdbms.engine.customQuery.QueryManager;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.hardcode.gdbms.engine.data.NoSuchTableException;

import com.hardcode.gdbms.engine.data.edition.DataWare;

import com.hardcode.gdbms.engine.instruction.FieldNotFoundException;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.DBDriverExceptionType;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.DriverIOExceptionType;

import com.iver.cit.gvsig.fmap.DriverNotLoadedExceptionType;

import com.iver.cit.gvsig.fmap.GenericDriverExceptionType;

import com.iver.cit.gvsig.fmap.LegendDriverExceptionType;

import com.iver.cit.gvsig.fmap.ProgressListener;

import com.iver.cit.gvsig.fmap.ViewPort;

import com.iver.cit.gvsig.fmap.drivers.ConnectionFactory;

import com.iver.cit.gvsig.fmap.drivers.DBException;

import com.iver.cit.gvsig.fmap.drivers.DBLayerDefinition;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.drivers.IConnection;

import com.iver.cit.gvsig.fmap.drivers.IVectorialDatabaseDriver;

import com.iver.cit.gvsig.fmap.drivers.IVectorialJDBCDriver;

import com.iver.cit.gvsig.fmap.drivers.RasterDriver;

import com.iver.cit.gvsig.fmap.drivers.VectorialDriver;

import com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver;

import com.iver.cit.gvsig.fmap.drivers.WithDefaultLegend;

import com.iver.cit.gvsig.fmap.operations.arcview.ArcJoin;

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;

import com.iver.utiles.ExceptionDescription;

import com.sun.media.jai.codec.SeekableOutputStream;

/**

 * Crea un adaptador del driver que se le pasa como par?metro en los m?todos

 * createLayer. Si hay memoria suficiente se crea un FLyrMemory que pasa todas

 * las features del driver a memoria

 */

public class LayerFactory {

        private static Logger logger = Logger.getLogger(LayerFactory.class

                        .getName());

        private static String driversPath = "../FMap 03/drivers";

        private static String writersPath = "../FMap 03/drivers";

        private static DriverManager driverManager;

        private static WriterManager writerManager;

        private static DataSourceFactory dataSourceFactory;

        /**

         * This Hashtable allows to register an alternative LayerClass for

         * an specific LayerClass than is attempting to create this factory

         */

        private static Hashtable layerClassMapping = new Hashtable();

        /**

         * Map en el que se guarda para cada fuente de datos a?adida al sistema, el

         * adaptador que la maneja. Ha de ser un TreeMap ya que esta clase define la

         * igualdad entre las claves a traves del m?todo equals de las mismas. Los

         * objetos FileSource, DBSource y WFSSource tienen definido el m?todo equals

         * de forma que devuelven true cuando dos objetos apuntan a la misma fuente

         * de datos

         */

        private static TreeMap sourceAdapter;

        /*

         * Crea un RandomVectorialFile con el driver que se le pasa como par?metro y

         * guard?ndose el nombre del fichero para realizar los accesos, la capa

         * tendr? asociada la proyecci?n que se pasa como parametro tambi?n

         *

         * @param layerName Nombre de la capa. @param driverName Nombre del driver.

         * @param f fichero. @param proj Proyecci?n.

         *

         * @return FLayer. @throws DriverException

         *

         * @throws DriverException @throws DriverIOException

         */

        public static FLayer createLayer(String layerName, String driverName,

                        File f, IProjection proj) throws DriverException {

                // Se obtiene el driver que lee

                DriverManager dm = getDM();

                try {

                        Driver d = dm.getDriver(driverName);

                        if (d instanceof VectorialFileDriver) {

                                return createLayer(layerName, (VectorialFileDriver) d, f, proj);

                        } else if (d instanceof RasterDriver) {

                                return createLayer(layerName, (RasterDriver) d, f, proj);

                        }

                } catch (DriverLoadException e) {

                        //hay un poco de lio sobre que excepciones se dejan subir

                        //arriba y que excepciones se quedan en LayerFactory

                        //(esto se debe a que queremos intentar recuperar ciertas capas)

                        //las excepciones de este metodo se dejan subir todas, puesto

                        //que las excepciones de los dos otros metodos createLayer si que

                        //se atrapan

                        DriverNotLoadedExceptionType exceptionType =

                                new DriverNotLoadedExceptionType();

                        exceptionType.setDriverName(driverName);

                        DriverException exception =

                                new DriverException(e, exceptionType);

                        throw exception;

                }

                return null;

        }

        /**

         * It creates a FLayer (FLyrVect) which reads its data from a file driver,

         * projected in the specified projection.

         *

         * @param layerName

         *            name of the layer

         * @param d

         *            vectorial file driver to read layer's data

         * @param f

         *            file associated to the driver

         * @param proj

         *            layer projection

         *

         * @return FLayer new vectorial layer

         *

         * @throws DriverException

         */

        public static FLayer createLayer(String layerName, VectorialFileDriver d,

                        File f, IProjection proj)

        /*throws DriverException*/ {

                // TODO Comprobar si hay un adaptador ya

                VectorialFileAdapter adapter = new VectorialFileAdapter(f);

                adapter.setDriver((VectorialDriver) d);

                FLyrVect capa = new FLyrVect();

                capa.setName(layerName);

                // TODO Meter esto dentro de la comprobaci?n de si hay memoria

                if (false) {

                } else {

                        capa.setSource(adapter);

                        capa.setProjection(proj);

                }

                try {

                        // Le asignamos tambi?n una legenda por defecto acorde con

                        // el tipo de shape que tenga. Tampoco s? si es aqu? el

                        // sitio adecuado, pero en fin....

                        if (d instanceof WithDefaultLegend) {

                                WithDefaultLegend aux = (WithDefaultLegend) d;

                                adapter.start();

                                capa.setLegend((VectorialLegend) aux.getDefaultLegend());

                                adapter.stop();

                        } else {

                                capa.setLegend(LegendFactory.createSingleSymbolLegend(capa

                                                .getShapeType()));

                        }

                } catch (FieldNotFoundException e) {

                        //this exception is caused in legend creation

                        LegendDriverExceptionType excepType =

                                new LegendDriverExceptionType("Error al construir la leyenda");

                        //TODO Para hacer esto extensible tiene que usarse puntos

                        //de extension, y comparar las clases de leyendas registradas

                        VectorialLegend legend = (VectorialLegend)

                                ((WithDefaultLegend)d).getDefaultLegend();

                        excepType.setLegendLabelField(legend.getLabelField());

                        excepType.setLegendHeightField(legend.getLabelHeightField());

                        excepType.setLegendRotationField(legend.getLabelRotationField());

                        DriverException exception = new DriverException(e, excepType);

                        capa.setAvailable(false);

                        capa.addError(exception);

                } catch (DriverIOException e) {

                        //this error is caused for file IO problems

                        DriverIOExceptionType excepType =

                                new DriverIOExceptionType();

                        excepType.setFile(f);

                        DriverException exception = new DriverException(e, excepType);

                        capa.setAvailable(false);

                        capa.addError(exception);

                }

                /*

                 * catch(DriverException e){

                 * ESTO HAY QUE CAPTURARLO,DE FORMA QUE CREATELAYER NO LANCE NINGUNA

                 * EXCEPCION (A NO SER QUE SEA IRRECUPERABLE)

                 * }

                 */

                catch(Exception e){

                        e.printStackTrace();

                        GenericDriverExceptionType type = new GenericDriverExceptionType();

                        DriverException exception = new DriverException(e, type);

                        capa.setAvailable(false);

                        capa.addError(exception);

                }

                return capa;

        }

        /**

         * Creates a new vectorial layer from a generic layer (by generic whe mean

         * that we dont know a priory its origin: file, memory, jdbc database, etc.

         *

         * @param layerName

         * @param d

         * @param proj

         * @return

         * @throws DriverException

         */

        public static FLayer createLayer(String layerName, VectorialDriver d,

                        IProjection proj)

        /*

        throws DriverException

        */{

                VectorialAdapter adapter = null;

                if (d instanceof VectorialFileDriver) {

                        adapter = new VectorialFileAdapter(((VectorialFileDriver) d)

                                        .getFile());

                } else if (d instanceof IVectorialJDBCDriver) {

                        adapter = new VectorialDBAdapter();

                } else {

                        adapter = new VectorialDefaultAdapter();

                }

                adapter.setDriver((VectorialDriver) d);

                FLyrVect capa = new FLyrVect();

                capa.setName(layerName);

                capa.setSource(adapter);

                capa.setProjection(proj);

                try {

                        // Le asignamos tambi?n una legenda por defecto acorde con

                        // el tipo de shape que tenga. Tampoco s? si es aqu? el

                        // sitio adecuado, pero en fin....

                        if (d instanceof WithDefaultLegend) {

                                WithDefaultLegend aux = (WithDefaultLegend) d;

                                adapter.start();

                                capa.setLegend((VectorialLegend) aux.getDefaultLegend());

                                adapter.stop();

                        } else {

                                capa.setLegend(LegendFactory.createSingleSymbolLegend(capa

                                                .getShapeType()));

                        }

                } catch (FieldNotFoundException e) {

//                        this exception is caused in legend creation

                        LegendDriverExceptionType excepType =

                                new LegendDriverExceptionType("error al construir la leyenda, campo no encontrado");

                        //TODO Para hacer esto extensible tiene que usarse puntos

                        //de extension, y comparar las clases de leyendas registradas

                        VectorialLegend legend = (VectorialLegend)

                                ((WithDefaultLegend)d).getDefaultLegend();

                        excepType.setDriverName(d.getName());

                        excepType.setLegendLabelField(legend.getLabelField());

                        excepType.setLegendHeightField(legend.getLabelHeightField());

                        excepType.setLegendRotationField(legend.getLabelRotationField());

                        DriverException exception = new DriverException(e, excepType);

                        capa.setAvailable(false);

                        capa.addError(exception);

                } catch (DriverIOException e) {

                        //by design, start and stop calls to adapter could

                        //cause this exception.

                        //but JDBC implementations catchs all exceptions,

                        //and rest of layers (WFSLayer, etc.) dont use LayerFactory

                        ExceptionDescription type = null;

                        if (d instanceof VectorialFileDriver) {

                                File f = ((VectorialFileDriver)adapter).getFile();

                                type =

                                        new DriverIOExceptionType();

                                ((DriverIOExceptionType)type).setFile(f);

                        }else{

                                type = new GenericDriverExceptionType();

                        }

                        DriverException exception = new DriverException(e, type);

                        capa.setAvailable(false);

                        capa.addError(exception);

                }catch(Exception e){

                        GenericDriverExceptionType type = new GenericDriverExceptionType();

                        DriverException exception = new DriverException(e, type);

                        capa.setAvailable(false);

                        capa.addError(exception);

                }

                return capa;

        }

        /**

         * Crea una capa Raster a partir del nombre driver, fichero y proyecci?n.

         *

         * @param layerName

         *            Nombre de la capa.

         * @param d

         *            RasterDriver.

         * @param f

         *            Fichero.

         * @param proj

         *            Proyecci?n.

         *

         * @return Nueva capa de tipo raster.

         *

         * @throws DriverIOException

         */

        public static FLyrRaster createLayer(String layerName, RasterDriver d,

                        File f, IProjection proj) throws DriverException {

                RasterAdapter adapter = new RasterFileAdapter(f);

                adapter.setDriver(d);

                Class layerClass;

                try {

                        layerClass = getLayerClassForLayerClassName(FLyrRaster.class.getName());

                } catch (ClassNotFoundException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                FLyrRaster capa;

                try {

                        capa = (FLyrRaster)layerClass.newInstance();

                } catch (InstantiationException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                } catch (IllegalAccessException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                capa.setName(layerName);

                // TODO Meter esto dentro de la comprobaci?n de si hay memoria

                if (false) {

                } else {

                        capa.setSource(adapter);

                        capa.setProjection(proj);

                        try {

                                capa.load();

                        } catch (DriverIOException e) {

                                throw new DriverException(e);

                        }

                }

                return capa;

        }

        /**

         * Crea una capa Raster a partir del nombre driver, fichero y proyecci?n y

         * coordenadas de georeferenciaci?n. Esta funci?n es para georeferenciar

         * capas raster. Para imagenes que no tienen georeferenciaci?n hay que

         * asignarle una temporal, normalmente a partir de la vista activa.

         *

         * @param layerName

         *            Nombre de la capa.

         * @param d

         *            RasterDriver.

         * @param f

         *            Fichero.

         * @param proj

         *            Proyecci?n.

         * @param extent

         *            Extent de la vista activa

         *

         * @return Nueva capa de tipo raster.

         *

         * @throws DriverIOException

         */

        public static FLyrRaster createLayer(String layerName, RasterDriver d,

                        File f, IProjection proj, ViewPort vp) throws DriverException {

                RasterAdapter adapter = new RasterFileAdapter(f);

                adapter.setDriver(d);

                Class layerClass;

                try {

                        layerClass = getLayerClassForLayerClassName(FLyrRaster.class.getName());

                } catch (ClassNotFoundException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                FLyrRaster capa;

                try {

                        capa = (FLyrRaster)layerClass.newInstance();

                } catch (InstantiationException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                } catch (IllegalAccessException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                capa.setName(layerName);

                // TODO Meter esto dentro de la comprobaci?n de si hay memoria

                if (false) {

                } else {

                        capa.setSource(adapter);

                        capa.setProjection(proj);

                        // capa.setTempExtent(vp);

                        try {

                                capa.load();

                        } catch (DriverIOException e) {

                                throw new DriverException(e);

                        }

                }

                return capa;

        }

        /**

         * Creates a new raster layer in memory. To create this layer type we have to set a data

         * buffer and a bounding box instead of a file. Don't use without CMS raster library that

         * include MemoryRasterDriver implementation.

         * @param layerName Layer name

         * @param d raster driver

         * @param buf data buffer

         * @param ext bounding box

         * @param proj projection

         * @return raster layer

         * @throws DriverException

         */

        public static FLyrRaster createLayer(String layerName, RasterDriver d,

                        RasterBuf buf, Extent ext, IProjection proj) throws DriverException {

                RasterAdapter adapter = new RasterFileAdapter(null);

                adapter.setDriver(d);

                Class layerClass;

                try {

                        layerClass = getLayerClassForLayerClassName(FLyrRaster.class.getName());

                } catch (ClassNotFoundException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                FLyrRaster capa;

                try {

                        capa = (FLyrRaster)layerClass.newInstance();

                } catch (InstantiationException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                } catch (IllegalAccessException e1) {

                        e1.printStackTrace();

                        throw new DriverException(e1);

                }

                capa.setName(layerName);

                // TODO Meter esto dentro de la comprobaci?n de si hay memoria

                if (false) {

                } else {

                        capa.setSource(adapter);

                        capa.setProjection(proj);

                        capa.setBuffer(buf);

                        capa.setExtent(ext);

                        try {

                                capa.load();

                        } catch (DriverIOException e) {

                                throw new DriverException(e);

                        }

                }

                return capa;

        }

        /**

         * Crea un RandomVectorialWFS con el driver que se le pasa como par?metro y

         * guard?ndose la URL del servidor que se pasa como par?metro

         *

         * @param driver

         * @param host

         * @param port

         * @param user

         * @param password

         * @param dbName

         * @param tableName

         * @param proj

         *

         * @return Capa creada.

         *

         * @throws UnsupportedOperationException

         */

        public static FLayer createLayer(IVectorialDatabaseDriver driver,

                        String host, int port, String user, String password, String dbName,

                        String tableName, IProjection proj) {

                throw new UnsupportedOperationException();

        }

        public static FLayer createDBLayer(IVectorialDatabaseDriver driver,

                        String layerName, IProjection proj) {

                FLyrVect capa = new FLyrVect();

                capa.setName(layerName);

                VectorialDBAdapter dbAdapter = new VectorialDBAdapter();

                dbAdapter.setDriver(driver);

                capa.setSource(dbAdapter);

                capa.setProjection(proj);

                try {

                        if (driver instanceof WithDefaultLegend) {

                                WithDefaultLegend aux = (WithDefaultLegend) driver;

                                dbAdapter.start();

                                capa.setLegend((VectorialLegend) aux.getDefaultLegend());

                                dbAdapter.stop();

                        } else {

                                capa.setLegend(LegendFactory.createSingleSymbolLegend(capa

                                                .getShapeType()));

                        }

                        if (driver instanceof IDelayedDriver)

                        {

                                // Por defecto, los drivers est?n listos para entregar

                                // features al terminar su initialize. Pero con los drivers

                                // que implementan IDelayedDriver, el driver es responsable

                                // de avisar cu?ndo est? listo

                                capa.getFLayerStatus().setDriverLoaded(false);

                                ((IDelayedDriver) driver).addDriverEventListener(new DefaultDelayedDriverListener(capa));

                        }

                        // PARCHE: Llamamos a getXmlEntity del driver para que se rellenen

                        // los valores de host, port, etc, necesarios para un posible reload

                        //FIXME: Se vuelve a dejar como estaba... el problema esta en el DefaultDBDriver.getXMLEntiy()

                        //       y comentarizemos esto o no, si no arreglamos ese metodo da problemas de persistencia

                        driver.setXMLEntity(driver.getXMLEntity());

                } catch (FieldNotFoundException e) {

                        LegendDriverExceptionType excepType =

                                new LegendDriverExceptionType("Error al construir la leyenda, campo no encontrado");

                        //TODO Para hacer esto extensible tiene que usarse puntos

                        //de extension, y comparar las clases de leyendas registradas

                        VectorialLegend legend = (VectorialLegend)

                                ((WithDefaultLegend)driver).getDefaultLegend();

                        excepType.setLegendLabelField(legend.getLabelField());

                        excepType.setLegendHeightField(legend.getLabelHeightField());

                        excepType.setLegendRotationField(legend.getLabelRotationField());

                        DriverException exception = new DriverException(e, excepType);

                        capa.setAvailable(false);

                        capa.addError(exception);

                        return capa;

                        // throw new UnsupportedOperationException(e.getMessage());

                } catch (DriverException e) {

                        DBDriverExceptionType excepType =

                                new DBDriverExceptionType();

                        excepType.setDriverName(driver.getName());

                        excepType.setTableName(driver.getTableName());

                        DriverException exception = new DriverException(e, excepType);

                        capa.addError(exception);

                        capa.setAvailable(false);

                        return capa;

                        // throw new UnsupportedOperationException(e.getMessage());

                } catch (Exception e) {

                        ExceptionDescription excepType = new GenericDriverExceptionType();

                        DriverException exception = new DriverException(e, excepType);

                        capa.addError(exception);

                        capa.setAvailable(false);

                        return capa;

                }

                return capa;

        }

        /**

         * @param driver

         * @param layerName

         * @param object

         * @return

         * @throws SQLException

         * @throws DriverIOException

         * @throws IOException

         * @throws DriverLoadException

         * @throws com.hardcode.gdbms.engine.data.driver.DriverException

         * @throws NoSuchTableException

         * @throws ClassNotFoundException

         * @throws

         */

        public static FLayer createDisconnectedDBLayer(IVectorialDatabaseDriver driver,

                        String layerName, IProjection proj, ProgressListener listener)

                        throws DBException, IOException, DriverIOException,

                        DriverLoadException, NoSuchTableException,

                        com.hardcode.gdbms.engine.data.driver.DriverException,

                        ClassNotFoundException {

                VectorialDisconnectedDBAdapter dbAdapter = new VectorialDisconnectedDBAdapter();

                dbAdapter.setDriver(driver);

                DataSource ds = dbAdapter.getRecordset();

                ds.start();

                String database = dataSourceFactory.getTempFile();

                String[] fieldNames = new String[ds.getFieldCount() + 1];

                System.arraycopy(ds.getFieldNames(), 0, fieldNames, 1, ds

                                .getFieldCount());

                fieldNames[0] = "the_geom";

                int[] types = new int[fieldNames.length];

                types[0] = Types.BINARY;

                for (int i = 1; i < types.length; i++) {

                        types[i] = ds.getFieldType(i - 1);

                }

                String dsName=null;

                try {

                        dsName = dataSourceFactory.createTable(database,

                                        ds.getPKNames(), fieldNames, types);

                } catch (SQLException e) {

                        throw new DBException(e);

                }

                DBLayerDefinition lyrDef = new DBLayerDefinition();

                lyrDef.setTableName(dsName);

                lyrDef.setName(layerName);

                lyrDef.setFieldNames(ds.getFieldNames());

                lyrDef.setFieldGeometry("the_geom");

                lyrDef.setFieldID(ds.getPKNames()[0]);

                lyrDef.setClassToInstantiate("org.hsqldb.jdbcDriver");

                dataSourceFactory.addDBDataSourceByTable(dsName, null, 0, "sa", "",

                                database, dsName, "GDBMS HSQLDB Transactional driver");

                DataSource local = dataSourceFactory.createRandomDataSource(dsName,

                                DataSourceFactory.MANUAL_OPENING);

                local.start();

                DataWare dw = local

                                .getDataWare(DataSourceFactory.DATA_WARE_COHERENT_ROW_ORDER);

                dw.start();

                long t1 = System.currentTimeMillis();

                dw.beginTrans();

                if (listener == null) {

                        listener = new ProgressListener() {

                                /**

                                 * @see com.iver.cit.gvsig.fmap.ProgressListener#progress(int)

                                 */

                                public void progress(int n) {

                                        // do nothing

                                }

                        };

                }

                for (int i = 0; i < dbAdapter.getShapeCount(); i++) {

                        Value[] row = new Value[ds.getFieldCount() + 1];

                        byte[] bytes = dbAdapter.getShape(i).toWKB();

                        row[0] = ValueFactory.createValue(bytes);

                        for (int j = 0; j < ds.getFieldCount(); j++) {

                                row[j + 1] = ds.getFieldValue(i, j);

                        }

                        dw.insertFilledRow(row);

                        listener.progress(100 * i / dbAdapter.getShapeCount());

                }

                long t2 = System.currentTimeMillis();

                dw.commitTrans();

                long t3 = System.currentTimeMillis();

                System.out.println((t2 - t1) + " - " + (t3 - t2));

                dw.stop();

                local.stop();

                ds.stop();

                IVectorialJDBCDriver cacheDriver = (IVectorialJDBCDriver) LayerFactory

                                .getDM().getDriver("HSQLDB Driver");

                Class.forName("org.hsqldb.jdbcDriver");

                IConnection conn=ConnectionFactory.createConnection("jdbc:hsqldb:file:" + database, "sa", "");

                cacheDriver.setData(conn, lyrDef);

                cacheDriver.setWorkingArea(driver.getWorkingArea());

                return createDBLayer(cacheDriver, layerName, proj);

        }

        /**

         * Crea una FLyrComplexRaster que ataca al driver que se pasa como

         * par?metro.

         *

         * @param driver

         * @param f

         * @param proj

         *

         * @throws IllegalArgumentException

         *             Si se pasa un driver que no implementa

         *             GeorreferencedRasterDriver o NotGeorreferencedRasterDriver

         */

        public static void createLayer(RasterDriver driver, File f, IProjection proj)

                        throws IllegalArgumentException {

        }

        /**

         * Devuelve el DriverManager.

         *

         * @return DriverManager.

         */

        public static DriverManager getDM() {

                initializeDriverManager();

                return driverManager;

        }

        /**

         * Devuelve el WriterManager.

         *

         * @return WriterManager.

         */

        public static WriterManager getWM() {

                initializeWriterManager();

                return writerManager;

        }

        /**

         * Inicializa el DriverManager.

         */

        private static void initializeDriverManager() {

                if (driverManager == null) {

                        driverManager = new DriverManager();

                        driverManager.loadDrivers(new File(LayerFactory.driversPath));

                        Throwable[] failures = driverManager.getLoadFailures();

                        for (int i = 0; i < failures.length; i++) {

                                logger.error("", failures[i]);

                        }

                        getDataSourceFactory().setDriverManager(driverManager);

                        getDataSourceFactory().initialize();

                        QueryManager.registerQuery(new ArcJoin());

                }

        }

        /**

         * Inicializa el DriverManager.

         */

        private static void initializeWriterManager() {

                if (writerManager == null) {

                        writerManager = new WriterManager();

                        writerManager.loadWriters(new File(LayerFactory.writersPath));

                        Throwable[] failures = writerManager.getLoadFailures();

                        for (int i = 0; i < failures.length; i++) {

                                logger.error("", failures[i]);

                        }

                        getDataSourceFactory().setWriterManager(writerManager);

                        getDataSourceFactory().initialize();

                        // QueryManager.registerQuery(new ArcJoin());

                }

        }

        /**

         * sets drivers Directory

         *

         * @param path

         */

        public static void setDriversPath(String path) {

                LayerFactory.driversPath = path;

                initializeDriverManager();

        }

        /**

         * sets writers Directory

         *

         * @param path

         */

        public static void setWritersPath(String path) {

                LayerFactory.writersPath = path;

                initializeWriterManager();

        }

        /**

         * @return Returns the dataSourceFactory.

         */

        public static DataSourceFactory getDataSourceFactory() {

                if (dataSourceFactory == null) {

                        dataSourceFactory = new DataSourceFactory();

                }

                return dataSourceFactory;

        }

        /**

         * Set a class to use instead of the originalLayerClassName.

         *

         * @param originalLayerClassName name of class to relpace

         * @param layerClassToUse Class than implements FLayer interface to use

         *

         * @see  getLayerClassForLayerClassName(String,Class)

         * @see  unregisterLayerClassForName(String)

        */

        public static void registerLayerClassForName (String originalLayerClassName, Class layerClassToUse){

                boolean isFLayer = false;

                Class[] interfaces = layerClassToUse.getInterfaces();

                for (int i = 0;i < interfaces.length; i++){

                        if (interfaces[i] == FLayer.class){

                                isFLayer = true;

                                break;

                        }

                }

                if (!isFLayer){

                        throw new ClassCastException("The class "+ layerClassToUse.getName() + "must implements FLayer");

                }

                layerClassMapping.put(originalLayerClassName,layerClassToUse);

        }

        /**

         * Unregister the originalLayerClassName class replacement.

         *

         * @param originalLayerClassName name of class to relpace

         * @param layerClassToUse Class than implements FLayer interface to use

         * @return true if the class had been registered

         *

         * @see  getLayerClassForLayerClassName(String,Class)

         * @see  unregisterLayerClassForName(String)

        */

        public static boolean unregisterLayerClassForName (String originalLayerClassName){

                return layerClassMapping.remove(originalLayerClassName) != null;

        }

        /**

         * Gets the class to use for the layerClassName.

         * If isn't registered an alternative class for this layerClass

         * the this returns 'Class.forName(layerClassName)'

         *

         * @param layerClassName

         * @return Class implements FLayer to use

         * @throws ClassNotFoundException

         *

         * @see  registerLayerClassForName(String,Class)

         * @see  unregisterLayerClassForName(String)

         */

        public static Class getLayerClassForLayerClassName(String layerClassName) throws ClassNotFoundException{

                Class layerClass = (Class)layerClassMapping.get(layerClassName);

                if (layerClass == null){

                        layerClass = Class.forName(layerClassName);

                }

                return layerClass;

        }

}