| gvSIG desktop 1

package com.iver.cit.gvsig.geoprocess.core;

import java.io.File;

import java.util.ArrayList;

import java.util.Properties;

import com.iver.cit.gvsig.fmap.core.IFeature;

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

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

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

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

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISchemaManager;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.edition.writers.shp.ShpWriter;

import com.iver.cit.gvsig.geoprocess.core.fmap.XTypes;

import com.iver.utiles.FileUtils;

/**

 * This writer wraps three ShpWriters, one for points, one for lines

 * and one for polygons geometry types.

 * <br>

 * 

 * It allows you to save a FLyrVect with MULTI shape type in SHP file

 * format (that doesnt allow to mix different geometry types).

 * To do that, this IWriter creates a different SHP file for any geometry

 * type, in a transparent manner for the programmer. <br>

 * If your geometries doesnt hava a given geometry type, the Writer wont

 * create a file for this geometry type.

 *<br>

 * <code>

 * MultiShpWriter writer = new MultiShpWriter();

 * writer.setFile(dxfFile);

 * writer.initialize(layerDefinition);

 * writer.preProcess();

 * # obtain features from an iterator

 * writer.process(feature);

 * writer.postProcess();

 * </code>

 * 

 */

public class MultiShpWriter implements IWriter{

        /**

         * original file name selected by user

         */

        String file = null;

        /**

         * original layer definition

         */

        ILayerDefinition layerDefinition;//only works with layers (no only tables)

        IWriter polygons;

        File polygonsFile;

        IWriter lines;

        File linesFile;

        IWriter points;

        File pointsFile;

        public void preProcess() throws EditionException {

        }

        /**

         * Returns all ShpWriter's created by this wrapper

         * (only those wich writes a type of the processed geometries)

         * @return

         */

        public IWriter[] getWriters(){

                IWriter[] solution;

                ArrayList list = new ArrayList();

                if(polygons != null)

                        list.add(polygons);

                if(lines != null)

                        list.add(lines);

                if(points != null)

                        list.add(points);

                solution = new IWriter[list.size()];

                list.toArray(solution);

                return solution;

        }

        public void postProcess() throws EditionException {

                if(polygons != null)

                        polygons.postProcess();

                if(lines != null)

                        lines.postProcess();

                if(points != null)

                        points.postProcess();

        }

        /**

         * Give access to the Writer that processes polygon geometries

         * (and creates it if it hasnt yet)

         * @return

         * @throws EditionException

         */

        private IWriter getPolygonsWriter() throws EditionException{

                if(polygons == null){

                        polygons = new ShpWriter();

                        //TODO Hacer que LayerDefinition sea cloneable

                        SHPLayerDefinition newDefinition = 

                                (SHPLayerDefinition) cloneDef(layerDefinition);

                        //we clone layerdefinition to change

                        //shape type

                        newDefinition.setShapeType(XTypes.POLYGON);

                        polygonsFile = new File(file+"_POL.shp");

                        newDefinition.setFile(polygonsFile);

                        ((ShpWriter)polygons).setFile(polygonsFile);

                        polygons.initialize(newDefinition);

                        getSchemaManager(polygons, polygonsFile).

                                createOrAlterSchema(newDefinition);

                }

                return polygons;

        }

        /**

         * Given a Writer, and the file where we want to save persistent features,

         * it returns an associated ISchemaManager (whose responsability is 

         * to create the new schema-for files create the new files)

         * @param writer

         * @param file

         * @return

         */

        private ISchemaManager getSchemaManager(final IWriter writer, 

                                                                                                final File file){

                return new ISchemaManager(){

                        public void createOrAlterSchema(ITableDefinition layerDefinition) throws EditionException {

                                writer.preProcess();

                        }

                        public void drop() throws EditionException {

                                if(!file.delete())

                                        throw new EditionException("No se pudo borrar el fichero shp");

                                String strFichshx = file.

                                                                getAbsolutePath().

                                                                replaceAll("\\.shp", ".shx");

                                String shxPath = strFichshx.replaceAll("\\.SHP", ".SHX");

                                if(! new File(shxPath).delete())

                                        throw new EditionException("No se puede borrar el fichero shx");

                                String strFichDbf = file.

                                                                getAbsolutePath().

                                                                replaceAll("\\.shp", ".dbf");

                                String dbfPath = strFichDbf.replaceAll("\\.SHP", ".DBF");

                                if(! new File(dbfPath).delete())

                                        throw new EditionException("No se puede borrar el fichero dbf");        

                        }

                };

        }

        /**

         * From a given layer definition, it creates a new layer definition

         * 'clon' of the initial. 

         * It is useful to avoid local changes made by individual Writers to the

         * definition affects the others writers (for example, change the shape type

         * of the writer)

         * @param definition

         * @return

         */

        private ILayerDefinition cloneDef(ILayerDefinition definition){

                ILayerDefinition solution = null;

                if(definition instanceof SHPLayerDefinition){

                        SHPLayerDefinition def = (SHPLayerDefinition)definition;

                        solution = new SHPLayerDefinition();

                        solution.setName(def.getName());

                        FieldDescription[] fields = 

                                def.getFieldsDesc();

                        solution.setFieldsDesc(fields);

                }

                return solution;

        }

        /**

         * Give access to the Writer that processes line geometries

         * (and creates it if it hasnt yet)

         * @return

         * @throws EditionException

         */

        private IWriter getLinesWriter() throws EditionException{

                if(lines == null){

                        lines = new ShpWriter();

                        SHPLayerDefinition newDefinition = 

                                (SHPLayerDefinition) cloneDef(layerDefinition);

                        //we clone layerdefinition to change

                        //shape type

                        newDefinition.setShapeType(XTypes.LINE);

                        linesFile = new File(file+"_LIN.shp");

                        newDefinition.setFile(linesFile);

                        ((ShpWriter)lines).setFile(linesFile);

                        lines.initialize(newDefinition);

                        getSchemaManager(lines, linesFile).

                                createOrAlterSchema(newDefinition);

                }

                return lines;

        }

        /**

         * Give access to the Writer that processes point geometries

         * (and creates it if it hasnt yet)

         * @return

         * @throws EditionException

         */

        private IWriter getPointsWriter() throws EditionException{

                if(points == null){

                        points = new ShpWriter();

                        //TODO Hacer que LayerDefinition sea cloneable

                        SHPLayerDefinition newDefinition = 

                                (SHPLayerDefinition) cloneDef(layerDefinition);

                        //we clone layerdefinition to change

                        //shape type

                        newDefinition.setShapeType(XTypes.POINT);

                        pointsFile = new File(file+"_PT.shp");

                        newDefinition.setFile(pointsFile);

                        ((ShpWriter)points).setFile(pointsFile);

                        points.initialize(newDefinition);

                        getSchemaManager(points, pointsFile).

                                createOrAlterSchema(newDefinition);

                }

                return points;

        }

        /**

         * Giving an edited row, writes it with the Writer associated to

         * its geometry type

         */

        public void process(IRowEdited row) throws EditionException {

                IFeature feature = (IFeature) row.getLinkedRow();

                int geometryType = feature.getGeometry().getGeometryType();

                switch(geometryType){

                case XTypes.POINT:

                        getPointsWriter().process(row);

                break;

                case XTypes.LINE:

                case XTypes.ELLIPSE:

                case XTypes.ARC:

                case XTypes.CIRCLE:

                        getLinesWriter().process(row);

                break;

                case XTypes.POLYGON:

                        getPolygonsWriter().process(row);

                break;

                }

        }

        /**

         * Sets the file where save the results

         * @param f

         */

        public void setFile(File f)

        {

                file = FileUtils.

                                getFileWithoutExtension(f);

        }

        public String getFileName(){

                return file;

        }

        public String getCapability(String capability) {

                return "";

        }

        public void setCapabilities(Properties capabilities) {

        }

        public boolean canWriteAttribute(int sqlType) {

                return true;

        }

        public void initialize(ITableDefinition layerDefinition) throws EditionException {

                this.layerDefinition = (ILayerDefinition) layerDefinition;

        }

        public String getName() {

                return "MULTI File Writer";

        }

}