Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.store.csv;

import java.io.File;

import java.io.FileOutputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.Writer;

import java.util.Locale;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.supercsv.io.CsvListWriter;

import org.supercsv.prefs.CsvPreference;

/**

 *

 * @author osc

 */

public class CSVFeatureWriter {

    private Envelope envelope = null;

    private boolean calculate_envelope = false;

    private CsvListWriter listWriter = null;

    private CsvPreference csvpreferences = null;

    private Writer writer = null;

    private FeatureType ftype;

    private File file;

    private String[] values;

    private FeatureAttributeDescriptor[] descriptors;

    private DataTypesManager.Coercion convert = null;

    private int errorcounts = 0;

    private Throwable lasterror = null;

    private Locale locale = null;

    private CSVStoreParameters storeParameters;

    private static final Logger logger = LoggerFactory.getLogger(CSVFeatureWriter.class);

    private String charset = null;

    public void initialize(CSVStoreParameters storeParameters, File file, FeatureType ftype, CsvPreference csvpreferences) {

        this.file = file;

        this.ftype = ftype;

        this.storeParameters = storeParameters;

        this.locale = CSVStoreParameters.getLocale(this.storeParameters);

        if (csvpreferences == null) {

            this.csvpreferences = CSVStoreParameters.getPredefinedCSVPreferences(storeParameters);

        } else {

            this.csvpreferences = csvpreferences;

        }

        if (this.ftype != null) {

            this.descriptors = this.ftype.getAttributeDescriptors();

            if (ftype.getDefaultGeometryAttributeName() != null) {

                this.calculate_envelope = true;

            }

        }

        this.convert = ToolsLocator.getDataTypesManager().getCoercion(org.gvsig.tools.dataTypes.DataTypes.STRING);

        this.errorcounts = 0;

        this.charset = CSVStoreParameters.getCharset(storeParameters);

    }

    public void beginAppend() {

        try {

            FileOutputStream fos = new FileOutputStream(file, true);

            if (this.charset != null) {

                this.writer = new OutputStreamWriter(fos, this.charset);

            } else {

                this.writer = new OutputStreamWriter(fos);

            }

            this.listWriter = new CsvListWriter(this.writer, this.csvpreferences);

            if (ftype != null) {

                this.descriptors = ftype.getAttributeDescriptors();

                int n = 0;

                for (FeatureAttributeDescriptor descriptor : descriptors) {

                    if (descriptor.getEvaluator() == null) {

                        n++;

                    }

                }

                this.values = new String[n];

            }

        } catch (IOException e) {

            logger.warn("Can't open file for write (" + file.getAbsolutePath() + ").", e);

            throw new RuntimeException(e);

        }

    }

    public void begin() {

        try {

            this.writer = new FileWriter(file);

        } catch (IOException e) {

            logger.warn("Can't open file for write (" + file.getAbsolutePath() + ").", e);

            throw new RuntimeException(e);

        }

        this.listWriter = new CsvListWriter(this.writer, this.csvpreferences);

        int n = 0;

        for (FeatureAttributeDescriptor descriptor : descriptors) {

            if (descriptor.getEvaluator() == null) {

                n++;

            }

        }

        String[] header = new String[n];

        this.values = new String[n];

        n = 0;

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

            FeatureAttributeDescriptor descriptor = descriptors[i];

            if (descriptor.getEvaluator() == null) {

                String name = descriptor.getName();

                String typeName = descriptor.getDataTypeName();

                if (descriptor.getDataType().getType() == DataTypes.STRING) {

                    header[n++] = name + "__" + typeName + "__" + descriptor.getSize();

                } else {

                    header[n++] = name + "__" + typeName;

                }

            }

        }

        try {

            listWriter.writeHeader(header);

        } catch (Exception e) {

            logger.warn("Can't write header '" + header.toString() + "' file for write (" + file.getAbsolutePath() + ").", e);

            throw new RuntimeException(e);

        }

    }

    public void add(FeatureProvider feature) {

        if (this.calculate_envelope) {

            Geometry geom = feature.getDefaultGeometry();

            if (geom != null) {

                if (envelope == null) {

                    try {

                        envelope = (Envelope) geom.getEnvelope().clone();

                    } catch (CloneNotSupportedException e) {

                        logger.warn("Este error no deberia pasar, siempre se puede hacer un clone de un envelope.", e);

                    }

                } else {

                    envelope.add(geom.getEnvelope());

                }

            }

        }

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

            FeatureAttributeDescriptor descriptor = descriptors[i];

            if (descriptor.getEvaluator() == null) {

                Object value = feature.get(i);

                try {

                    if (this.convert != null && this.convert instanceof DataTypesManager.CoercionWithLocale) {

                        values[i] = (String) ((DataTypesManager.CoercionWithLocale) this.convert).coerce(value, this.locale);

                    } else {

                        values[i] = (String) this.convert.coerce(value);

                    }

                } catch (CoercionException e) {

                    try {

                        values[i] = value.toString();

                    } catch (Exception ex) {

                        values[i] = "";

                    }

                    if (errorcounts++ <= 10) {

                        this.lasterror = e;

                        logger.warn("Can't convert value of field " + i + " to string in CVS file '" + this.file.getAbsolutePath() + "'.", e);

                        if (errorcounts == 10) {

                            logger.warn("Too many error writing CVS file '" + this.file.getAbsolutePath() + "', don't output more.");

                        }

                    }

                }

            }

        }

        try {

            this.listWriter.writeHeader(values);

        } catch (IOException e) {

            if (errorcounts++ <= 10) {

                this.lasterror = e;

                logger.warn("Can't write values to CVS file '" + this.file.getAbsolutePath() + "'.", e);

                if (errorcounts == 10) {

                    logger.warn("Too many error writing CVS file '" + this.file.getAbsolutePath() + "', don't output more.");

                }

            }

        }

    }

    public void end() throws PerformEditingException {

        if (this.errorcounts > 0) {

            throw new PerformEditingException(this.file.getAbsolutePath(), lasterror);

        }

        if (listWriter != null) {

            try {

                listWriter.close();

            } catch (Exception ex) {

                // Ignore error

            }

            listWriter = null;

        }

        if (writer != null) {

            try {

                writer.close();

            } catch (Exception ex) {

                // Ignore error

            }

            writer = null;

        }

    }

    public Envelope getEnvelope() {

        return this.envelope;

    }

}