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.simplereader;

import org.gvsig.fmap.dal.store.csv.*;

import java.io.Closeable;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.Reader;

import java.net.URI;

import java.net.URL;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

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.CloseException;

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.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.FeatureQuery;

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.CreateFeatureException;

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

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

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

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

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.dal.store.csv.simplereaders.AbstractSimpleReader;

import org.gvsig.fmap.dal.store.csv.simplereaders.CSVReaderSuperCSV;

import org.gvsig.fmap.dal.store.csv.simplereaders.SimpleReader;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.SpatialIndexFactory;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dispose.DisposableIterator;

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.prefs.CsvPreference;

import org.gvsig.tools.dataTypes.CoercionContext;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.util.GetItemWithSize64;

@SuppressWarnings("UseSpecificCatch")

public class SimpleReaderStoreProvider extends AbstractMemoryStoreProvider implements

        ResourceConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleReaderStoreProvider.class);

    public static final String NAME = DataStore.CSV_PROVIDER_NAME;

    public static final String DESCRIPTION = "CSV file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private final ResourceProvider resource;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private boolean need_calculate_envelope = false;

    private final SimpleTaskStatus taskStatus;

    private final CSVFeatureWriter writer;

    private FeatureType featureType;

    private GetItemWithSize64<List<String>> virtualrows;

    private RowToFeatureTranslator rowToFeatureTranslator;

    private SpatialIndex spatialIndex;

    @SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})

    public SimpleReaderStoreProvider(

            CSVStoreParameters parameters,

            DataStoreProviderServices storeServices

        ) throws InitializeException {

        super(

                parameters,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        this.writer = new CSVFeatureWriter();

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

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

        this.taskStatus.setAutoremove(true);

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

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public boolean allowWrite() {

        return true;

    }

    private String getFullFileName() {

        // Usar solo para mostrar mensajes en el logger.

        String s;

        try {

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

        } catch (Exception e2) {

            s = "(unknow)";

        }

        return s;

    }

    @Override

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        this.data = new ArrayList<>();

        resource.setData(new HashMap());

        counterNewsOIDs = 0;

        try {

            loadFeatures();

        } catch (RuntimeException e) {

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

            throw e;

        } catch (Exception e) {

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

            throw new RuntimeException(e);

        }

    }

    @Override

    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 (Exception e) {

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

        }

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

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

        try {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.taskStatus.add();

            taskStatus.message(i18n.getTranslation("_Preparing_writing"));

            this.getResource().closeRequest();

            getResource().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    try {

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

                        features = getStoreServices().getFeatureStore().getFeatureSet();

                        taskStatus.message(i18n.getTranslation("_Writing_records"));

                        if (virtualrows == null) {

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

                            FeatureType ftype = getStoreServices().getDefaultFeatureType();

                            writer.initialize(getCSVParameters(), file, ftype, getCSVPreferences());

                            writer.begin();

                            it = features.fastIterator();

                            taskStatus.setRangeOfValues(0, features.getSize());

                            taskStatus.setCurValue(0);

                            while (it.hasNext()) {

                                taskStatus.incrementCurrentValue();

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

                            } else {

                                envelope = null;

                            }

                            resource.notifyChanges();

                            writer.end();

                            bboxFileSave(envelope);

                        } else {

                            CSVStoreParameters csvParams = getCSVParameters();

                            CSVStoreParameters tmpParams = (CSVStoreParameters) csvParams.getCopy();

                            String tmpBase = File.createTempFile("tmp_" + System.currentTimeMillis(), null).getAbsolutePath();

                            File tmpFile = new File(tmpBase + ".csv");

                            tmpParams.setFile(tmpFile);

                            FeatureType ftype = getStoreServices().getDefaultFeatureType();

                            writer.initialize(tmpParams, tmpFile, ftype, getCSVPreferences(),spatialIndex);

                            writer.begin();

                            it = features.fastIterator();

                            taskStatus.setIndeterminate();

                            taskStatus.setCurValue(0);

                            while (it.hasNext()) {

                                taskStatus.incrementCurrentValue();

                                if( taskStatus.isCancellationRequested() ) {

                                    taskStatus.cancel();

                                    LOGGER.info("CSV writing canceled ("+getFullFileName()+")");

                                    break;

                                }

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

                                }

                            }

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

                                envelope = writer.getEnvelope();

                            } else {

                                envelope = null;

                            }

                            resource.notifyChanges();

                            writer.end();

                            if( !taskStatus.isCancelled() ) {

                                if (!csvParams.getFile().delete()) {

                                    LOGGER.debug("Can't delete csv file '" + csvParams.getFile() + "'.");

                                    throw new IOException("Can't delete csv '"

                                            + FilenameUtils.getBaseName(csvParams.getFile().getAbsolutePath())

                                            + "' file to replace with the new csv.\nThe new csv is in temporary file '" + tmpFile.getAbsolutePath()

                                            + "'");

                                }

                                File csvFile = csvParams.getFile();

                                FileUtils.moveFile(tmpParams.getFile(), csvFile);

                                FileUtils.delete(new File(FilenameUtils.removeExtension(csvFile.getAbsolutePath())+".idx"));

                                bboxFileSave(envelope);

                                loadFeatures();

                            }

                        }

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

        }

    }

    private CsvPreference getCSVPreferences() {

        CSVReaderSuperCSV reader = new CSVReaderSuperCSV(getCSVParameters());

        return reader.getCSVPreferences();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

    @Override

    public boolean supportsAppendMode() {

        return true;

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void append(final FeatureProvider featureProvider) {

        //todo

        getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                //writer.append(getStoreServices().createFeature(featureProvider));

                writer.add(featureProvider);

                return null;

            }

        });

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void beginAppend() throws DataException {

        getResource().execute(new ResourceAction() {

            @Override

            public Object run() throws Exception {

                writer.initialize(

                        getCSVParameters(),

                        getCSVParameters().getFile(),

                        getFeatureStore().getDefaultFeatureType(),

                        getCSVPreferences()

                );

                writer.beginAppend();

                return null;

            }

        });

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public void endAppend() {

        try {

            getResource().execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    writer.end();

                    resource.notifyChanges(); //resourcesNotifyChanges();

                    counterNewsOIDs = -1;

                    return null;

                }

            });

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

                envelope = writer.getEnvelope();

            } else {

                envelope = null;

            }

            writer.end();

            this.close();

            bboxFileSave(envelope);

        } catch (Exception ex) {

            LOGGER.warn("Not been able to end append '" + this.getFullName() + "'.", ex);

        }

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        throw new NotYetImplemented();

    }

    @Override

    public Object createNewOID() {

        return counterNewsOIDs++;

    }

    protected void initializeFeatureTypes() throws InitializeException {

        try {

            this.open();

        } catch (OpenException e) {

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

        }

    }

    @Override

    @SuppressWarnings("Convert2Lambda")

    public Envelope getEnvelope() throws DataException {

        this.open();

        if (this.envelope != null) {

            return this.envelope;

        }

        this.envelope = bboxFileLoad();

        if (this.envelope != null) {

            return this.envelope;

        }

        if (!this.need_calculate_envelope) {

            return null;

        }

        try {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.taskStatus.add();

            this.taskStatus.message(i18n.getTranslation("_Calculating_envelope"));

            FeatureStore fs = this.getFeatureStore();

            FeatureType ft = fs.getDefaultFeatureType();

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

            this.taskStatus.setRangeOfValues(0, fs.getFeatureCount());

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

            fs.accept(new Visitor() {

                @Override

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

                    taskStatus.incrementCurrentValue();

                    if(taskStatus.isCancellationRequested()){

                        taskStatus.cancel();

                        throw new VisitCanceledException();

                    }

                    Feature f = (Feature) obj;

                    Geometry geom = f.getDefaultGeometry();

                    if (geom != null) {

                        try {

                            Envelope env = geom.getEnvelope();

                            envelope.add(env);

                        } catch(Exception ex) {

                            LOGGER.warn("Can't calculate envelop of geometry in feature '"+Objects.toString(f.getReference())+"'.",ex);

                        }

                    }

                }

            });

            bboxFileSave(envelope);

            taskStatus.terminate();

        } catch (VisitCanceledException e) {

            return null;

        } catch (BaseException e) {

            taskStatus.abort();

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

            return null;

        }

        this.need_calculate_envelope = false;

        return this.envelope;

    }

    @Override

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

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

                DataStoreNotification.RESOURCE_CHANGED,

                resource);

    }

    @Override

    public Object getSourceId() {

        return this.getCSVParameters().getFile();

    }

    @Override

    public String getName() {

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

        return FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

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

    }

    @Override

    public ResourceProvider getResource() {

        return resource;

    }

    private boolean isEmpty(String s) {

        if (s == null) {

            return true;

        }

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

    }

    private void init(CSVStoreParameters parameters, DataStoreProviderServices storeServices) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    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 final Coercion toDouble;

        private int errorcount = 0;

        ToPointEvaluaror(String[] pointDimensionNames) {

            this.xname = pointDimensionNames[0];

            this.yname = pointDimensionNames[1];

            if (pointDimensionNames.length > 2) {

                this.zname = pointDimensionNames[2];

            }

            this.geommgr = GeometryLocator.getGeometryManager();

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

        }

        @Override

        public Object evaluate(EvaluatorData data) throws EvaluatorException {

            try {

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

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

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

                if (zname != null) {

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

                    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;

            }

        }

        @Override

        public String getName() {

            return "ToPointEvaluaror";

        }

    }

    public static class RowToFeatureTranslator {

        private Coercion coercion[];

        private CoercionContext coercionContext[];

        private int sizes[];

        private String[] names;

        private final boolean ignore_errors;

        private long count_errors;

        private FeatureType csvFeatureType;

        public RowToFeatureTranslator(boolean ignore_errors) {

            this.ignore_errors = ignore_errors;

            this.count_errors = 0;

        }

        public int getColumnSize(int column) {

            return this.sizes[column];

        }

        public void initialize(FeatureType ftype) {

            this.csvFeatureType = ftype;

            int columns = this.csvFeatureType.size();

            this.names = new String[columns];

            this.coercion = new Coercion[columns];

            this.coercionContext = new CoercionContext[columns];

            this.sizes = new int[columns];

            int index = 0;

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

                FeatureAttributeDescriptor ad = this.csvFeatureType.getAttributeDescriptor(i);

                names[i] = null;

                if( ad.isComputed() ) {

                    continue;

                }

                names[index] = ad.getName();

                coercion[index] = ad.getCoercion();

                coercionContext[index] = ad.getCoercionContext();

                sizes[index] = ad.getSize();

                index++;

            }

        }

        public void translate(long rowindex, List<String> row, FeatureProvider feature) throws Exception {

            feature.setOID(rowindex);

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

                String name = names[i];

                if( name == null ) {

                    break;

                }

                Object rawvalue = row.get(i);

                try {

                    Object value = null;

                    if (coercion[i] != null) {

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

                    }

                    int findex = feature.getType().getIndex(name);

                    if( findex>=0 ) {

                        // Ojo que puede que se este filtrando el featuretype y no

                        // tenga todos los atributos, por ejemplo al pintar la vista.

                        feature.set(findex, value);

                    }

                    if (sizes[i] >= 0

                            && (value instanceof String || value instanceof URL

                            || value instanceof URI || value instanceof File)) {

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

                        if (sizes[i] < x) {

                            sizes[i] = x;

                        }

                    }

                } catch (Exception ex) {

                    if (!ignore_errors) {

                        throw ex;

                    }

                    if (count_errors++ < 10) {

                        LOGGER.warn("Can't load value of attribute " + name +"/" +i+" in row " + rowindex + ".", ex);

                    }

                    if (count_errors == 10) {

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

                    }

                }

            }

        }

    }

    private void loadFeatures() {

        InputStreamReader in = null;

        SimpleReader reader = null;

        try {

            taskStatus.setTitle("CSV "+this.getName());

            taskStatus.add();

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

            // Initialize the feature types

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

            CSVUtils.loadFeatureType(getCSVParameters(), edftype, true, taskStatus);

            FeatureType ftype = edftype.getNotEditableCopy();

            this.setFeatureType(ftype);

            in = CSVUtils.openFile(

                    this.getCSVParameters().getFile(),

                    CSVStoreParameters.getCharset(this.getCSVParameters())

            );

            reader = getSimpleReader(getCSVParameters(), in);

            if (CSVStoreParameters.isFirstLineHeader(getCSVParameters())) {

                reader.getHeader(); // Skip and ignore the header of file

            }

            this.rowToFeatureTranslator = new RowToFeatureTranslator(

                    CSVStoreParameters.getIgnoreErrors(getCSVParameters())

            );

            this.rowToFeatureTranslator.initialize(ftype);

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

                this.need_calculate_envelope = true;

            }

            I18nManager i18n = ToolsLocator.getI18nManager();

            taskStatus.message(i18n.getTranslation("_Loading"));

            if(this.virtualrows != null && this.virtualrows instanceof Closeable){

                IOUtils.closeQuietly((Closeable) this.virtualrows);

                this.virtualrows = null;

            }

            this.virtualrows = ((AbstractSimpleReader) reader).getVirtualRows(this.taskStatus);

            if (this.virtualrows == null) {

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

                int skipLines = CSVStoreParameters.getSkipLines(getCSVParameters());

                if (skipLines > 0) {

                    row = reader.skip(skipLines);

                }

                int limit = CSVStoreParameters.getLimit(getCSVParameters());

                while (row != null) {

                    taskStatus.incrementCurrentValue();

                    if( taskStatus.isCancellationRequested() ) {

                        taskStatus.cancel();

                        break;

                    }

                    FeatureProvider feature = this.createFeatureProvider(ftype);

                    this.rowToFeatureTranslator.translate(reader.getLine(), row, feature);

                    this.addFeatureProvider(feature);

                    if (limit > 0) {

                        if (limit < this.data.size()) {

                            break;

                        }

                    }

                    row = reader.read();

                }

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

                    if (this.rowToFeatureTranslator.getColumnSize(i) > 0) {

//                    if (sizes[i] > 0) {

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

//                        efad.setSize(sizes[i]);

                        efad.setSize(this.rowToFeatureTranslator.getColumnSize(i));

                    }

                }

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

                // haber cambiado.

                ftype = edftype.getNotEditableCopy();

                this.setFeatureType(ftype);

            } else {

                this.loadOrCreateSpatialIndex();

            }

            if( taskStatus.isRunning() ) {

                taskStatus.terminate();

            }

        } catch (Throwable ex) {

            taskStatus.abort();

            int lineno = 0;

            if (reader != null) {

                lineno = reader.getLine();

            }

            throw new RuntimeException("Problems reading file '" + getFullFileName() + "' near line " + lineno + ".", ex);

        } 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;

            }

            taskStatus.remove();

        }

    }

    @Override

    public void fixFeatureTypeFromParameters() {

        if(mustFixFeatureType() && featureType != null){

            this.setFeatureType(featureType);

        }

    }

    private boolean mustFixFeatureType() {

        try {

            String param_types_def = CSVStoreParameters.getRawFieldTypes(this.getParameters());

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

            String geometry_column = CSVStoreParameters.getGeometryColumn(this.getParameters());

            FeatureType dalFeatureType = this.getStoreServices().getDefaultFeatureType();

            if (StringUtils.isNotBlank(geometry_column)){

                FeatureAttributeDescriptor attr = dalFeatureType.getAttributeDescriptor(geometry_column);

                if(attr == null || attr.getType() !=  DataTypes.GEOMETRY){

                    return true;

                }

            }

            if (StringUtils.isNotBlank(param_types_def)

                    || pointDimensionNames != null) {

                for (FeatureAttributeDescriptor dalAttr : dalFeatureType) {

                    if(dalAttr.isComputed()){

                        continue;

                    }

                    FeatureAttributeDescriptor csvAttr = featureType.getAttributeDescriptor(dalAttr.getName());

                    if(csvAttr == null){

                        return true;

                    }

                    if(!dalAttr.get("all").equals(csvAttr.get("all"))){

                        return true;

                    }

                }

            }

        } catch (DataException ex) {

            LOGGER.warn("Can't check if should fix the feature type", ex);

        }

        return false;

    }

    private void setFeatureType(FeatureType ftype) {

        try {

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

            ftypes.add(ftype);

            this.featureType = ftype;

            if(this.getStoreServices().getDefaultFeatureType() == null){

                this.getStoreServices().setFeatureTypes(ftypes, ftype);

                return;

            }

            if(mustFixFeatureType()){

                this.getStoreServices().setFeatureTypes(ftypes, ftype);

            }

        } catch (DataException ex) {

            LOGGER.warn("Cant set feature type", ex);

        }

    }

    @Override

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType providerFeatureType, FeatureType featureType)

            throws DataException {

        this.open();

        if (this.virtualrows == null) {

            return super.createSet(query, providerFeatureType, featureType);

        }

        return new SimpleReaderSetProvider(this, query, providerFeatureType, featureType);

    }

    @Override

    public FeatureSetProvider createSet(FeatureQuery query, FeatureType featureType)

            throws DataException {

        this.open();

        if (this.virtualrows == null) {

            return super.createSet(query, featureType);

        }

        return new SimpleReaderSetProvider(this, query, featureType, featureType);

    }

    public List<String> getRowByIndex(long index) {

        try {

            this.open();

        } catch(Exception ex) {

            throw new RuntimeException("Can't get row by index", ex);

        }

        if (this.virtualrows == null) {

            return null;

        }

        List<String> line = this.virtualrows.get64(index);

        if( line!=null ) {

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

                String s = line.get(i);

                line.set(i, CSVReaderSuperCSV.unescapeCRLF(s));

            }

        }

        return line;

    }

    public RowToFeatureTranslator getRowToFeatureTranslator() {

        if (this.rowToFeatureTranslator == null) {

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