Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.OpenException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

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

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

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

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

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

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

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.dal.feature.spi.FeatureStoreProviderServices;

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.evaluator.AbstractEvaluator;

import org.gvsig.tools.evaluator.EvaluatorData;

import org.gvsig.tools.evaluator.EvaluatorException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.supercsv.comment.CommentStartsWith;

import org.supercsv.io.CsvListReader;

import org.supercsv.io.CsvListWriter;

import org.supercsv.prefs.CsvPreference;

import org.supercsv.quote.QuoteMode;

public class CSVStoreProvider extends AbstractMemoryStoreProvider implements

ResourceConsumer {

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

    public static final String NAME = "CSV";

    public static final String DESCRIPTION = "CSV file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private boolean need_calculate_envelope = false;

    private SimpleTaskStatus taskStatus;

    public CSVStoreProvider(CSVStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(

            parameters, 

            storeServices,

            FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("CSV");

        counterNewsOIDs = 0;

        File file = getCSVParameters().getFile();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

        initializeFeatureTypes();

    }

    private CSVStoreParameters getCSVParameters() {

        return (CSVStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        return true;

    }

    private String getFullFileName() {

            // Usar solo para mostrar mensajes en el logger.

                String s = "(unknow)";

                try { 

                        s = getCSVParameters().getFile().getAbsolutePath();

                } catch(Exception e2) {

                        s = "(unknow)";

                }

                return s;

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        this.data = new ArrayList<FeatureProvider>();

        resource.setData(new HashMap());

        counterNewsOIDs = 0;

                try {

                        loadFeatures();

                } catch (RuntimeException e) {

                        logger.warn("Can't load features from CSV '"+getFullFileName()+"'.", e);

                        throw e;

                } catch (Exception e) {

                        logger.warn("Can't load features from CSV '"+getFullFileName()+"'.", e);

                        throw new RuntimeException(e);

                }

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getCSVParameters().getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

        } catch (DataException e) {

            throw new ReadException(this.getProviderName(), e);

        } catch (ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    class Writer {

            private Envelope envelope = null;

                private boolean calculate_envelope = false;

                private CsvListWriter listWriter = null;

                private CsvPreference csvpreferences = null;

                private FileWriter fwriter = null;

                private FeatureType ftype;

                private File file;

                private String[] values;

                private FeatureAttributeDescriptor[] descriptors;

                private Coercion convert = null;

                private int errorcounts =0;

                private Throwable lasterror = null;

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

                    this.file = file;

                    this.ftype = ftype;

                        this.csvpreferences = csvpreferences;

                    if( csvpreferences == null ) {

                            this.csvpreferences = CsvPreference.STANDARD_PREFERENCE;

                    }

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

                            this.calculate_envelope = true;

                    }

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

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

                    this.errorcounts = 0;

            }

            public void begin() {

                    try {

                                this.fwriter = 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.fwriter,this.csvpreferences);

                    int n = 0;

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

                            FeatureAttributeDescriptor descriptor = descriptors[i];

                            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 type = descriptor.getDataTypeName();

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

                            }

                    }

            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());

                                        }

                                }

                        }

                    int n = 0;

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

                            FeatureAttributeDescriptor descriptor = descriptors[i];

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

                                        Object value = feature.get(i);

                                    try {

                                            n++;

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

                                        } catch (CoercionException e) {

                                                try {

                                                        values[n] = value.toString();

                                                } catch(Exception ex) {

                                                        values[n] = "";

                                                }

                                                if( errorcounts++ <= 10 ) {

                                                        this.lasterror = e;

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

                                                        if( errorcounts == 10 ) {

                                                                logger.warn("Too many error writing CVS file '"+getFullFileName()+"', 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 '"+getFullFileName()+"'.",e);

                                        if( errorcounts == 10 ) {

                                                logger.warn("Too many error writing CVS file '"+getFullFileName()+"', 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( fwriter!=null ) {

                            try {

                                    fwriter.close();

                            } catch(Exception ex) {

                                    // Ignore error

                            }

                                fwriter=null ;

                        }

            }

            public Envelope getEnvelope() {

                    return this.envelope;

            }

    }

    public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException {

        try {

            this.taskStatus.add();

            taskStatus.message("_preparing");

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    try {

                        File file = (File) resource.get();

                        Writer writer = new Writer();

                        writer.initialize(file,getStoreServices().getDefaultFeatureType(),null);

                        features =

                            getStoreServices().getFeatureStore()

                            .getFeatureSet();

                        List<FeatureProvider> newdata = new ArrayList<FeatureProvider>();

                        writer.begin();

                        it = features.fastIterator();

                        taskStatus.setRangeOfValues(0,0);

                        long counter=0;

                        while (it.hasNext()) {

                            taskStatus.setCurValue(counter++);

                            FeatureProvider feature = getStoreServices().getFeatureProviderFromFeature(

                                (org.gvsig.fmap.dal.feature.Feature) it.next());

                            writer.add(feature);

                            if (feature.getOID() == null){

                                logger.warn("feature without OID");

                                feature.setOID(createNewOID());

                            }

                            newdata.add(feature);

                        }

                        data = newdata;

                        if (writer.getEnvelope() != null){

                            envelope = writer.getEnvelope().getGeometry().getEnvelope();

                        }

                        resource.notifyChanges();

                        writer.end();

                    } finally {

                        if (it != null) {

                            it.dispose();

                        }

                        if (features != null) {

                            features.dispose();

                        }

                    }

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            this.taskStatus.abort();

            throw new PerformEditingException(getResource().toString(), e);

        } finally {

            this.taskStatus.remove();

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    public int getOIDType() {

        return DataTypes.LONG;

    }

    public boolean supportsAppendMode() {

        return false;

    }

    public void append(FeatureProvider featureProvider) {

            throw new UnsupportedOperationException();

    }

    public void beginAppend() {

            throw new UnsupportedOperationException();

    }

    public void endAppend() {

            throw new UnsupportedOperationException();

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public Object createNewOID() {

        return new Long(counterNewsOIDs++);

    }

    protected void initializeFeatureTypes() throws InitializeException {

        try {

            this.open();

        } catch (OpenException e) {

            throw new InitializeException(this.getProviderName(), e);

        }

    }

    public Envelope getEnvelope() throws DataException {

        this.open();

        if( this.envelope!= null )  {

                return this.envelope;

        }

        if( !this.need_calculate_envelope ) {

                return null;

        }

        FeatureStore fs = this.getFeatureStore();

        FeatureType ft = fs.getDefaultFeatureType();

        FeatureAttributeDescriptor fad = ft.getAttributeDescriptor(ft.getDefaultGeometryAttributeIndex());

        try {

            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(fad.getGeomType().getSubType());

                        fs.accept(new Visitor() {

                                public void visit(Object obj) throws VisitCanceledException, BaseException {

                                        Feature f = (Feature) obj;

                                        Geometry geom = f.getDefaultGeometry();

                                        envelope.add(geom.getEnvelope());

                                }

                        });

                } catch (BaseException e) {

                        logger.warn("Can't calculate the envelope of CSV file '"+this.getFullName()+"'.",e);

                        this.envelope = null;

                }

        this.need_calculate_envelope = false;

        return this.envelope;

    }

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

            try {

                return this.getEnvelope();

            } catch (DataException e) {

                return null;

            }

        } else {

            if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

                IProjection pro = CSVStoreParameters.getCRS(this.getCSVParameters());

                if (pro != null){

                    return pro;

                }

            }

        }

        return super.getDynValue(name);

    }

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    public Object getSourceId() {

        return this.getCSVParameters().getFile();

    }

    public String getName() {

        String name = this.getCSVParameters().getFile().getName();

        return FilenameUtils.getBaseName(name);

    }

    public String getFullName() {

        return this.getCSVParameters().getFile().getAbsolutePath();

    }

    public ResourceProvider getResource() {

        return resource;

    }

    private boolean isEmpty(String s) {

            if( s==null ) {

                    return true;

            }

            return s.trim().length()==0;

    }

        private CsvPreference getCSVPreferences() {

                try {

                        String s = null;

                        char quoteChar;

                        int delimiterChar;

                        String endOfLineSymbols;

                        DynObject params = this.getParameters();

                        CsvPreference.Builder builder = null;

                        CsvPreference defaultPreference = CSVStoreParameters

                                        .getPredefinedCSVPreferences(params);

                        if (defaultPreference == null) {

                                defaultPreference = CsvPreference.STANDARD_PREFERENCE;

                        }

                        endOfLineSymbols = CSVStoreParameters.getRecordSeparator(params);

                        if (isEmpty(endOfLineSymbols)) {

                                endOfLineSymbols = defaultPreference.getEndOfLineSymbols();

                        }

                        s = CSVStoreParameters.getQuoteCharacter(params);

                        if (isEmpty(s)) {

                                quoteChar = (char) defaultPreference.getQuoteChar();

                        } else {

                                quoteChar = s.charAt(0);

                        }

                        s = CSVStoreParameters.getDelimiter(params);

                        if (isEmpty(s)) {

                                delimiterChar = defaultPreference.getDelimiterChar();

                        } else {

                                delimiterChar = s.charAt(0);

                        }

                        builder = new CsvPreference.Builder(quoteChar, delimiterChar,

                                        endOfLineSymbols);

                        s = CSVStoreParameters.getCommentStartMarker(params);

                        if (!isEmpty(s)) {

                                CommentStartsWith cs = new CommentStartsWith(s);

                                builder.skipComments(cs);

                        }

                        builder.surroundingSpacesNeedQuotes(CSVStoreParameters

                                        .getSurroundingSpacesNeedQuotes(params));

                        QuoteMode quoteMode = CSVStoreParameters.getQuoteMode(params);

                        if( quoteMode != null ) {

                                builder.useQuoteMode(quoteMode);

                        }

                        return builder.build();

                } catch (Exception e) {

                        logger.warn("Can't make preferences for CSV '" + getFullFileName()

                                        + "'.", e);

                        return null;

                }

        }

    private EditableFeatureType getFeatureType(String headers[]) {

                EditableFeatureType fType =        getStoreServices().createFeatureType(this.getName());

                fType.setHasOID(true);

                DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

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

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

                    String s = headers[i];

                    String typename = null;

                    if( s.contains(":") ) {

                            String[] ss = s.split(":");

                            headers[i] = ss[0];

                            typename = ss[1];

                            types[i] = dataTypesManager.getType(typename); 

                    } else if( s.contains("__") ) {

                                String[] ss = s.split("__");

                                headers[i] = ss[0];

                                typename = ss[1];

                                types[i] = dataTypesManager.getType(typename); 

                    } else {

                            types[i] = DataTypes.STRING;

                            typename = "string";

                    }

                        if( types[i]==DataTypes.INVALID ) {

                                types[i] = DataTypes.STRING;

                                logger.info("Type '"+typename+"' not valid for attribute '"+headers[i]+"' in CSV file '"+this.getFullFileName()+"'.");

                        }

            }

            int[] param_types = CSVStoreParameters.getFieldTypes(this.getParameters());

            if( param_types != null ) {

                for( int i=0; i<types.length && i<param_types.length; i++) {

                        types[i] = param_types[i];

                }

            }

            int[] param_sizes = CSVStoreParameters.getFieldSizes(this.getParameters());

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

                        int fieldType = types[i];

                        String fieldName = headers[i];

                        EditableFeatureAttributeDescriptor fad = fType.add(fieldName, fieldType);

                        if( param_sizes!=null && param_sizes[i]>0 ) {

                                fad.setSize(param_sizes[i]);

                        }

                        if( fieldType == DataTypes.GEOMETRY && fType.getDefaultGeometryAttributeName() == null) {

                                fType.setDefaultGeometryAttributeName(fieldName);

                        }

                }

            String[] pointDimensionNames = CSVStoreParameters.getPointDimensionNames(this.getParameters());

            if( pointDimensionNames!= null ) {

                    EditableFeatureAttributeDescriptor attr = fType.add("GEOM", DataTypes.GEOMETRY, new ToPointEvaluaror(pointDimensionNames));

                    GeometryManager geommgr = GeometryLocator.getGeometryManager();

                    GeometryType gt;

                        try {

                                gt = geommgr.getGeometryType(Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM3D);

                            attr.setGeometryType(gt);

                        } catch (Exception e) {

                                logger.warn("Can't set geometry type for the calculated field in CSV file '"+getFullFileName()+"'.",e);

                        }

            }

                return fType;

    }

    static class ToPointEvaluaror extends AbstractEvaluator {

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

            private GeometryManager geommgr = null;

            private String xname = null;

            private String yname = null;

            private String zname = null;

                private Coercion toDouble;

                private int errorcount = 0;

            ToPointEvaluaror(String[] pointDimensionNames) {

                    this.xname = pointDimensionNames[0];

                    this.yname = pointDimensionNames[1];

                    if( pointDimensionNames.length >2 ) {

                            this.yname = pointDimensionNames[2];

                    }

                    this.geommgr = GeometryLocator.getGeometryManager();

                    this.toDouble = ToolsLocator.getDataTypesManager().getCoercion(DataTypes.DOUBLE);

            }

                public Object evaluate(EvaluatorData data) throws EvaluatorException {

                        try {

                                double x = ((Double) toDouble.coerce(data.getDataValue(xname))).doubleValue();

                                double y = ((Double) toDouble.coerce(data.getDataValue(yname))).doubleValue();

                                Point point = geommgr.createPoint(x, y,Geometry.SUBTYPES.GEOM3D);

                                if (zname != null) {

                                        double z = ((Double) toDouble.coerce(data.getDataValue(zname))).doubleValue();

                                        point.setCoordinateAt(2, z);

                                }

                                return point;

                        } catch (Exception ex) {

                                if( ++errorcount <5 ) {

                                        logger.warn("["+errorcount+"] Can't create point in CSV provider. XNAME='"+

                                                        xname + "', YNAME='"+yname+"', ZNAME='"+zname+"', data="+data.toString());

                                }

                                return null;

                        }

                }

                public String getName() {

                        return "ToPointEvaluaror";

                }

    }

        private void loadFeatures() throws IOException, DataException,

                        CoercionException, CloneNotSupportedException {

                //

                // http://supercsv.sourceforge.net/examples_reading.html

                // http://supercsv.sourceforge.net/apidocs/index.html

                //

                FileReader in = null;

                CsvListReader reader = null;

                try {

                        Envelope envelope = null;

                        String headers[] = null;

                        FeatureStoreProviderServices store = this.getStoreServices();

                        boolean ignore_errors = CSVStoreParameters.getIgnoreErrors(getCSVParameters());

                        // Initiaize the CSV parser

                        CsvPreference preferences = getCSVPreferences();

                        in = new FileReader(this.getCSVParameters().getFile());

                        reader = new CsvListReader(in, preferences);

                        headers = CSVStoreParameters.getHeaders(getCSVParameters());

                        if (headers == null) {

                                headers = reader.getHeader(true);

                                if (headers == null) {

                                        String msg = "Can't retrieve header from csv file '"

                                                        + this.getCSVParameters().getFile()

                                                                        .getAbsolutePath()

                                                        + "' and not specified in the parameters.";

                                        logger.warn(msg);

                                        throw new RuntimeException(msg);

                                }

                        }

                        // Initialize the feature types

                        EditableFeatureType edftype = this.getFeatureType(headers);

                        FeatureType ftype = edftype.getNotEditableCopy();

                        List<FeatureType> ftypes = new ArrayList<FeatureType>();

                        ftypes.add(ftype);

                        store.setFeatureTypes(ftypes, ftype);

                        Coercion coercion[] = new Coercion[ftype.size()];

                        int sizes[] = new int[ftype.size()];

                        for (int i = 0; i < ftype.size(); i++) {

                                sizes[i] = -1;

                                FeatureAttributeDescriptor ad = ftype.getAttributeDescriptor(i);

                                coercion[i] = ad.getDataType().getCoercion();

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

                                        if( ad.getSize() == 0 ) {

                                                // Es un string y no tiene un size asignado.

                                                // Lo ponemos a cero para calcularlo.

                                                sizes[i] = 0;

                                        }

                                }

                        }

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

                                this.need_calculate_envelope = true;

                        }

                        taskStatus.message("_loading");

                        int count = 0;

                        int count_errors = 0;

                        List<String> row = reader.read();

                        while (row != null) {

                                taskStatus.setCurValue(++count);

                                FeatureProvider feature = this.createFeatureProvider(ftype);

                                for (int i = 0; i < row.size(); i++) {

                                        Object rawvalue = row.get(i);

                                        try {

                                                Object value = coercion[i].coerce(rawvalue);

                                                feature.set(i, value);

                                                if (sizes[i] >= 0 && value != null) {

                                                        int x = ((String) value).length();

                                                        if (sizes[i] < x) {

                                                                sizes[i] = x;

                                                        }

                                                }

                                        } catch (RuntimeException ex) {

                                                if (!ignore_errors) {

                                                        throw ex;

                                                }

                                                if( count_errors++ <10 ) {

                                                        logger.warn("Can't load value of attribute "+i+" in row "+count+".",ex);

                                                }

                                                if( count_errors==10 ) {

                                                        logger.info("Too many errors, suppress messages.");

                                                }

                                        }

                                }

                                this.addFeatureProvider(feature);

                                row = reader.read();

                        }

                        for (int i = 0; i < ftype.size(); i++) {

                                if( sizes[i]>0 ) {

                                        EditableFeatureAttributeDescriptor efad = ((EditableFeatureAttributeDescriptor)edftype.getAttributeDescriptor(i));

                                        efad.setSize(sizes[i]);

                                }

                        }

                        // Volvemos a asignar al store el featuretype, ya que puede

                        // haber cambiado.

                        ftype = edftype.getNotEditableCopy();

                        ftypes = new ArrayList<FeatureType>();

                        ftypes.add(ftype);

                        store.setFeatureTypes(ftypes, ftype);

                        taskStatus.terminate();

                } finally {

                        if( reader != null ) {

                                try { 

                                        reader.close();

                                } catch(Exception ex) {

                                        // Do nothing

                                }

                                reader = null;

                        }

                        if( in != null ) {

                                try { 

                                        in.close();

                                } catch(Exception ex) {

                                        // Do nothing

                                }

                                in = null;

                        }

                }

        }

}