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

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Map;

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

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

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

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

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

import org.gvsig.fmap.geom.aggregate.MultiPoint;

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

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

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

import org.gvsig.timesupport.Interval;

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.dataTypes.DataTypesManager.CoercionWithLocale;

import org.gvsig.tools.dynobject.Tags;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.gvsig.tools.util.UnmodifiableBasicMap;

import org.gvsig.tools.util.UnmodifiableBasicMapToMapAdapter;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class SimpleSequentialReaderStoreProvider extends AbstractMemoryStoreProvider implements

        ResourceConsumer {

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

    private class ReaderData {

        private FeatureType defaultFeatureType;

        private List<FeatureType> featureTypes;

        private final List<FeatureProvider> features;

        private boolean needCalculateEnvelope;

        private String name;

        private long OIDcounter;

        private DataStore store;

        public ReaderData() {

            this.needCalculateEnvelope = false;

            this.features = new ArrayList<>();

            this.OIDcounter = 0;

            this.store = null;

        }

        public void addFeatureProvider(FeatureProvider feature) {

                feature.setOID(this.OIDcounter++);

                this.features.add(feature);

        }

        public void setFeatureTypes(List<FeatureType> featureTypes, FeatureType defaultFeatureType) {

            this.featureTypes = featureTypes;

            this.defaultFeatureType = defaultFeatureType;

        }

        public void setNeedCalculateEnvelope(boolean needCalculateEnvelope) {

            this.needCalculateEnvelope = needCalculateEnvelope;

        }

        public boolean getNeedCalculateEnvelope() {

            return this.needCalculateEnvelope;

        }

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public List<FeatureType> getFeatureTypes() {

            return this.featureTypes;

        }

        public FeatureType getDefaultFeatureType() {

            return this.defaultFeatureType;

        }

        public List<FeatureProvider> getFeatures() {

            return this.features;

        }

        public DataStore getStore() throws InitializeException {

            if( this.store == null ) {

                SimpleSequentialReaderStoreProvider provider = new SimpleSequentialReaderStoreProvider(

                        readerFactory,

                        getParameters(),

                        null,

                        childrenData,

                        this

                );

                DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

                this.store = manager.openStore(

                        getParameters(), 

                        provider

                );

                provider.setStoreServices((FeatureStoreProviderServices) this.store);

                provider.name = this.name;

            }

            return this.store;

        }

    }

    class Children implements UnmodifiableBasicMap<String, DataStore> {

        // Con esta clase se pospone la creacion de los stores hasta que se 

        // pide cada uno de ellos, y no cuando se pide el Map de estos, ya

        // que el map se puede pedir solo para saber si hay o cuantos hay.

        @Override

        public DataStore get(String key) {

            for (ReaderData child : childrenData) {

                if( StringUtils.equalsIgnoreCase(child.getName(), key) ) {

                    try {

                        return child.getStore();

                    } catch (Exception ex) {

                        throw new RuntimeException(ex);

                    }

                }

            }

            return null;

        }

        @Override

        public boolean isEmpty() {

            return childrenData.isEmpty();

        }

        @Override

        public boolean containsKey(String key) {

            for (ReaderData child : childrenData) {

                if( StringUtils.equalsIgnoreCase(child.getName(), key) ) {

                    return true;

                }

            }

            return false;

        }

        @Override

        public Map<String, DataStore> toMap() {

            return new UnmodifiableBasicMapToMapAdapter<>(this);

        }

        @Override

        public int size() {

            return childrenData.size();

        }

        @Override

        public UnmodifiableBasicSet<String> keySet() {

            return new UnmodifiableBasicSet<String>() {

                @Override

                public boolean isEmpty() {

                    return childrenData.isEmpty();

                }

                @Override

                public int size() {

                    return childrenData.size();

                }

                @Override

                public Iterator<String> iterator() {

                    final Iterator<ReaderData> it = childrenData.iterator();

                    return new Iterator<String>() {

                        @Override

                        public boolean hasNext() {

                            return it.hasNext();

                        }

                        @Override

                        public String next() {

                            ReaderData theReaderData = it.next();

                            return theReaderData.getName();

                        }

                    };

                }

            };

        }

        @Override

        public Iterator<DataStore> iterator() {

            final Iterator<String> it = this.keySet().iterator();

            return new Iterator<DataStore>() {

                @Override

                public boolean hasNext() {

                    return it.hasNext();

                }

                @Override

                public DataStore next() {

                    String name = it.next();

                    return get(name);

                }

            };

        }

    }

    private final ResourceProvider resource;

    private Envelope envelope;

    private boolean need_calculate_envelope = false;

    private String name = "";

    private final SimpleSequentialReaderFactory readerFactory;

    private List<ReaderData> childrenData;

    private ReaderData readerData;

    public SimpleSequentialReaderStoreProvider(

            SimpleSequentialReaderFactory readerFactory,

            SimpleSequentialReaderStoreParameters parameters,

            DataStoreProviderServices storeServices

        ) throws InitializeException {

        this(readerFactory, parameters, storeServices, new ArrayList<ReaderData>(), null);

    }

    private SimpleSequentialReaderStoreProvider(

            SimpleSequentialReaderFactory readerFactory,

            SimpleSequentialReaderStoreParameters parameters,

            DataStoreProviderServices storeServices,

            List<ReaderData> childrenData,

            ReaderData readerData

        ) throws InitializeException {

        super(

                parameters,

                storeServices,

                FileHelper.newMetadataContainer(readerFactory.getName())

        );

        this.childrenData = childrenData;

        this.readerData = readerData;

        this.readerFactory = readerFactory;

        File file = getParameters().getFile();

        resource = this.createResource(

                FileResource.NAME,

                new Object[]{file.getAbsolutePath()}

        );

        resource.addConsumer(this);

        if( this.readerData!=null ) {

            this.name = this.readerData.getName();            

        }

        if( storeServices != null ) {

            initializeFeatureTypes();

        }

    }

    private void setStoreServices(FeatureStoreProviderServices storeServices) throws InitializeException {

        this.store = storeServices;

        initializeFeatureTypes();

    }

    @Override

    public SimpleSequentialReaderStoreParameters getParameters() {

        return (SimpleSequentialReaderStoreParameters) super.getParameters();

    }

    @Override

    public String getProviderName() {

        if( this.readerFactory==null ) {

            return "unknown";

        }

        return this.readerFactory.getName();

    }

    @Override

    public boolean allowWrite() {

        return false;

    }

    private String getFullFileName() {

        // Usar solo para mostrar mensajes en el logger.

        String s;

        try {

            s = getParameters().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());

        try {

            loadFeatures();

        } catch (RuntimeException e) {

            LOGGER.warn("Can't load features from '"+getProviderName()+"' file '" + getFullFileName() + "'.", e);

            throw e;

        } catch (Exception e) {

            LOGGER.warn("Can't load features from '"+getProviderName()+"' file '" + 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.getParameters().getFile().getParent());

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

        } catch (DataException | ValidateDataParametersException e) {

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

        }

    }

    @Override

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

        throw new UnsupportedOperationException();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    public int getOIDType() {

        return DataTypes.LONG;

    }

    @Override

    public boolean supportsAppendMode() {

        return false;

    }

    @Override

    public void append(FeatureProvider featureProvider) {

        throw new UnsupportedOperationException();

    }

    @Override

    public void beginAppend() {

        throw new UnsupportedOperationException();

    }

    @Override

    public void endAppend() {

        throw new UnsupportedOperationException();

    }

    @Override

    public Object createNewOID() {

        throw new UnsupportedOperationException();

    }

    protected void initializeFeatureTypes() throws InitializeException {

        try {

            this.open();

        } catch (OpenException e) {

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

        }

    }

    @Override

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

                @Override

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

                    Feature f = (Feature) obj;

                    Geometry geom = f.getDefaultGeometry();

                    if ( geom != null ) {

                        envelope.add(geom.getEnvelope());

                    }

                }

            });

        } catch (BaseException e) {

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

            this.envelope = 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 = this.getParameters().getCRS();

                if ( pro != null ) {

                    return pro;

                }

                FeatureType type;

                try {

                    type = this.getStoreServices().getDefaultFeatureType();

                    pro = type.getDefaultSRS();

                    if( pro!=null ) {

                        return pro;

                    }

                } catch (DataException ex) {

                }

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

                DataStoreNotification.RESOURCE_CHANGED,

                resource);

    }

    @Override

    public Object getSourceId() {

        return this.getParameters().getFile();

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public String getFullName() {

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

    }

    @Override

    public ResourceProvider getResource() {

        return resource;

    }

    private String[] split(String value, String separators) {

        int firstSeparatorPosition = 1000000;

        Character sep = null;

        for (char ch : separators.toCharArray()) {

            int pos = value.indexOf(ch);

            if( pos>0 && pos<firstSeparatorPosition ) {

                sep = ch;

                firstSeparatorPosition = pos;

            }

        }

        if( sep == null ) {

            return new String[] { value };

        }

        return value.split("["+sep+"]");

    }

    private class FieldTypeParser {

        public String name = null;

        public int type = DataTypes.STRING;

        public int size = 0;

        public int geomType = Geometry.TYPES.GEOMETRY;

        public int geomSubtype = Geometry.SUBTYPES.GEOM2D;

        public Map<String,String> tags = new HashMap<>();

        public Map<String,String> assignments = new HashMap<>();

        private String typename = "string";

        FieldTypeParser() {

        }

        private int getType(String value) {

            DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

            return dataTypesManager.getType(typename);

        }

        @SuppressWarnings("UseSpecificCatch")

        public boolean parse(String value) {

            String[] args;

            if ( value.contains("__") ) {

                args = value.split("__");

            } else {

                args = split(value, ":/#@!;-");

                if( args.length == 1 ) {

                    this.name = value;

                    return true;

                }

            }                        

            int n = 0;

            this.name = args[n++];

            if( n >= args.length ) {

                return true;

            }

            this.typename = args[n++];

            this.type = this.getType(this.typename);

            if ( this.type == DataTypes.INVALID ) {

                this.geomType = GeometryUtils.getGeometryType(this.typename);

                if( this.geomType==Geometry.TYPES.UNKNOWN )  {

                    this.type = DataTypes.STRING;

                    LOGGER.info("Type '" + this.typename + "' not valid for attribute '" + value + "' in '"+getProviderName()+"' file '" + getFullFileName() + "'.");

                } else {

                    this.typename = "GEOMETRY";

                    this.type = DataTypes.GEOMETRY;

                }

            }

            switch(this.type) {

                case DataTypes.STRING:

                    this.size = 50;

                    break;

                case DataTypes.INT:

                    this.size = 10;

                    break;

                case DataTypes.LONG:

                    this.size = 20;

                    break;

                case DataTypes.FLOAT:

                    this.size = 10;

                    break;

                case DataTypes.DOUBLE:

                    this.size = 20;

                    break;

                default:

                    this.size = 0;

            }

            while (n < args.length) {

                String option = args[n++].toLowerCase();

                switch (option) {

                    case "size":

                        try {

                            this.size = Integer.parseInt(args[n++]);

                        } catch (Exception ex) {

                            LOGGER.warn("Ignore incorrect field size for field " + value + " in '"+getProviderName()+"' file '" + getFullFileName() + "'.", ex);

                        }

                        break;

                    case "tag": {

                            String x = args[n++];

                            int pos = x.indexOf("=");

                            if( pos < 0 ) {

                                this.tags.put(x, null);

                            } else {

                                this.tags.put( 

                                        StringUtils.substring(x, 0, pos),

                                        StringUtils.substring(x, pos+1)

                                );

                            }

                            break;

                        }

                    case "set": {

                            String x = args[n++];

                            int pos = x.indexOf("=");

                            if( pos < 0 ) {

                                this.assignments.put(x, null);

                            } else {

                                this.assignments.put( 

                                        StringUtils.substring(x, 0, pos),

                                        StringUtils.substring(x, pos+1)

                                );

                            }

                            break;

                        }

                    default:

                        LOGGER.warn("Illegal argumente '"+option+"' for field '"+this.name+"' in '"+getProviderName()+"' file '" + getFullFileName() + "' ("+value+").");

                }

            }

            return true;

        }

    }

    private EditableFeatureType getFeatureType(List<String> headers, int automaticTypes[]) {

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

        fType.setHasOID(true);

//        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

        FieldTypeParser[] fieldTypes = new FieldTypeParser[headers.size()];

        //

        // Calculamos cuales pueden ser los tipos de datos

        //

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

            fieldTypes[i] = new FieldTypeParser();

        }

        // Asuminos los tipos pasados por parametro, que se supone

        // son los detectados automaticamente.

        if ( automaticTypes != null ) {

            for ( int i = 0; i < fieldTypes.length && i < automaticTypes.length; i++ ) {

                fieldTypes[i].type = automaticTypes[i];

            }

        }

        // Luego probamos con lo que diga las cabezeras, sobreescribiendo

        // los tipos anteriores en caso de definirse en la cabezara.

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

            fieldTypes[i].parse(headers.get(i));

        }

        // Y por ultimo hacemos caso a lo que se haya especificado en los parametros

        // de apertura del reader, teniendo esto prioridad sobre todo.

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

        if ( param_types != null ) {

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

                fieldTypes[i].type = param_types[i];

            }

        }

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

        if ( param_sizes != null ) {

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

                if ( param_sizes[i] > 0 ) {

                    fieldTypes[i].size = param_sizes[i];

                }

            }

        }

        //

        // Una vez ya sabemos los tipos de datos rellenamos el feature-type

        //

        DataTypesManager dataTypesManager = ToolsLocator.getDataTypesManager();

        for (FieldTypeParser fieldType : fieldTypes) {

            EditableFeatureAttributeDescriptor fad = fType.add(fieldType.name, fieldType.type);

            fad.setSize(fieldType.size);

            if (fieldType.type == DataTypes.GEOMETRY ) {

                fad.setGeometryType(fieldType.geomType, fieldType.geomSubtype);

                if( fType.getDefaultGeometryAttributeName() == null ) {

                    fType.setDefaultGeometryAttributeName(fieldType.name);

                }

            }

            for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {

                try {

                    switch(entry.getKey().toLowerCase()) {

                        case "hidden":

                            fad.setHidden((boolean) dataTypesManager.coerce(DataTypes.BOOLEAN, entry.getValue()));

                            break;

                        case "allownull":

                            fad.setAllowNull((boolean) dataTypesManager.coerce(DataTypes.BOOLEAN, entry.getValue()));

                            break;

                        case "pk":

                        case "ispk":

                        case "primarykey":

                        case "isprimarykey":

                            fad.setIsPrimaryKey((boolean) dataTypesManager.coerce(DataTypes.BOOLEAN, entry.getValue()));

                            break;

                        case "isautomatic":

                        case "automatic":

                            fad.setIsAutomatic((boolean) dataTypesManager.coerce(DataTypes.BOOLEAN, entry.getValue()));

                            break;

                        case "time":

                        case "istime":

                            fad.setIsTime((boolean) dataTypesManager.coerce(DataTypes.BOOLEAN, entry.getValue()));

                            break;

                        case "profile":

                            fad.setDataProfileName((String) dataTypesManager.coerce(DataTypes.STRING, entry.getValue()));

                            break;

                        case "group":

                            fad.setGroup((String) dataTypesManager.coerce(DataTypes.STRING, entry.getValue()));

                            break;

                        case "description":

                            fad.setDescription((String) dataTypesManager.coerce(DataTypes.STRING, entry.getValue()));

                            break;

                        case "label":

                            fad.setLabel((String) dataTypesManager.coerce(DataTypes.STRING, entry.getValue()));

                            break;

                        case "expression":

                            // Los campos calculados los procesamos en una segunda

                            // pasada, cuando ya estan definidos el resto de los campos

                            // ya que pueden requerir campos que aun no se han definido.

                            break;

                        case "size":

                            fad.setSize((int) dataTypesManager.coerce(DataTypes.INT, entry.getValue()));

                            break;

                        case "precision":

                            fad.setPrecision((int) dataTypesManager.coerce(DataTypes.INT, entry.getValue()));

                            break;

                        case "order":

                            fad.setOrder((int) dataTypesManager.coerce(DataTypes.INT, entry.getValue()));

                            break;

                        case "interval":

                            fad.setInterval((Interval) dataTypesManager.coerce(DataTypes.INTERVAL, entry.getValue()));

                            break;

                        case "geomtype":

                        case "geometrytype":

                            fad.setGeometryType(entry.getValue());

                            break;

                        case "srs":

                            fad.setSRS(entry.getValue());

                            break;

                    }

                } catch (Exception ex) {

                    LOGGER.warn("Can't set property '"+entry.getKey()+"' of '"+fad.getName()+"'.", ex);

                }

            }

            Tags tags = fad.getTags();

            for (Map.Entry<String, String> entry : fieldType.tags.entrySet()) {

                tags.set(entry.getKey(), entry.getValue());

            }

        }

        // Processamos ahora los campos calculados

        for (FieldTypeParser fieldType : fieldTypes) {

            EditableFeatureAttributeDescriptor fad = fType.getEditableAttributeDescriptor(fieldType.name);

            for (Map.Entry<String, String> entry : fieldType.assignments.entrySet()) {

                try {

                    switch(entry.getKey().toLowerCase()) {

                        case "expression":

                            fad.setFeatureAttributeEmulator((String) dataTypesManager.coerce(DataTypes.STRING, entry.getValue()));

                            break;

                    }

                } catch (Exception ex) {

                    LOGGER.warn("Can't set property '"+entry.getKey()+"' in '"+fad.getName()+"' of '"+getFullFileName()+"'.", ex);

                }

            }

        }

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

        if ( pointDimensionNames != null ) {

            PointAttributeEmulator emulator = new PointAttributeEmulator(pointDimensionNames);

            EditableFeatureAttributeDescriptor attr = fType.add("the_geom", DataTypes.GEOMETRY, emulator);

            GeometryManager geommgr = GeometryLocator.getGeometryManager();

            GeometryType gt;

            try {

                if ( emulator.fieldNames != null && emulator.fieldNames.length <= 2 ) {

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

                } else {

                        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 '"+getProviderName()+"' file '" + getFullFileName() + "'.", e);

            }

        }

        return fType;

    }

    class PointAttributeEmulator implements FeatureAttributeEmulator {

        private static final int XNAME = 0;

        private static final int YNAME = 1;

        private static final int ZNAME = 2;

        private final GeometryManager geommgr;

        private final String[] fieldNames;

        private final Coercion toDouble;

        private int errorcount = 0;

        public PointAttributeEmulator(String[] pointDimensionNames) {

            if ( pointDimensionNames.length > 2 ) {

                this.fieldNames = new String[3];

                this.fieldNames[ZNAME] = pointDimensionNames[2];

            } else {

                this.fieldNames = new String[2];

            }

            this.fieldNames[XNAME] = pointDimensionNames[0];

            this.fieldNames[YNAME] = pointDimensionNames[1];

            this.geommgr = GeometryLocator.getGeometryManager();

            DataTypesManager datatypeManager = ToolsLocator.getDataTypesManager();

            this.toDouble = datatypeManager.getCoercion(DataTypes.DOUBLE);

        }

        @Override

        @SuppressWarnings("UseSpecificCatch")

        public Object get(Feature feature) {

            try {

                Object valueX = feature.get(this.fieldNames[XNAME]);

                valueX = toDouble.coerce(valueX);

                if ( valueX == null ) {

                    return null;

                }

                Object valueY = feature.get(this.fieldNames[YNAME]);

                valueY = toDouble.coerce(valueY);

                if ( valueY == null ) {

                    return null;

                }

                Object valueZ = null;

                if ( this.fieldNames.length > 2 ) {

                    valueZ = toDouble.coerce(feature.get(this.fieldNames[ZNAME]));

                    if ( valueZ == null ) {

                        return null;

                    }

                }

                double x = ((Double) valueX);

                double y = ((Double) valueY);

                Point point;

                if ( this.fieldNames.length > 2 ) {

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

                    double z = ((Double) valueZ);

                    point.setCoordinateAt(2, z);

                } else {

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

                }

                return point;

            } catch (Exception ex) {

                if ( ++errorcount < 5 ) {

                    LOGGER.warn("[" + errorcount + "] Can't create point from '"+getProviderName()+"' file."+

                            "XNAME='" + this.fieldNames[XNAME] + 

                            "', YNAME='" + this.fieldNames[YNAME] + 

                            "', ZNAME='" + ((this.fieldNames.length > 2)? this.fieldNames[ZNAME]: "(2D)") +

                            "' feature=" + feature.toString(), ex);

                }

                return null;

            }

        }

        @Override

        public void set(EditableFeature feature, Object value) {

            if ( value == null ) {

                return;

            }

            Point point;

            if ( value instanceof MultiPoint ) {

                point = (Point) ((MultiPoint) value).getPrimitiveAt(0);

            } else {

                point = (Point) value;

            }

            feature.set(this.fieldNames[XNAME], point.getX());

            feature.set(this.fieldNames[YNAME], point.getY());

            if ( this.fieldNames.length > 2 ) {

                feature.set(this.fieldNames[ZNAME], point.getCoordinateAt(2));

            }

        }

        @Override

        public boolean allowSetting() {

            return true;

        }

        @Override

        public String[] getRequiredFieldNames() {

            return this.fieldNames;

        }

    }

    private void loadFeatures() throws IOException, DataException,

            CoercionException, CloneNotSupportedException {

        ReaderData theReaderData = this.readerData;

        if( theReaderData==null ) {

            theReaderData = new ReaderData();

            SimpleSequentialReader reader = this.readerFactory.createReader(this.getParameters());

            try {

                loadFeatures(reader, theReaderData);

                this.childrenData = new ArrayList<>();

                for(SimpleSequentialReader childReader : reader.getChildren() ) {

                    ReaderData childData = new ReaderData();

                    loadFeatures(childReader, childData);

                    this.childrenData.add(childData);

                }

                this.readerData = theReaderData;

            } finally {

                reader.close();

            }

        }

        this.name = theReaderData.getName();

        FeatureStoreProviderServices theStore = this.getStoreServices();

        theStore.setFeatureTypes(theReaderData.getFeatureTypes(), theReaderData.getDefaultFeatureType());

        this.need_calculate_envelope = theReaderData.getNeedCalculateEnvelope();

        this.data = theReaderData.getFeatures();

    }

    private void loadFeatures(SimpleSequentialReader reader, ReaderData readerData) throws IOException, DataException,

            CoercionException, CloneNotSupportedException {

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        SimpleTaskStatus taskStatus = manager.createDefaultSimpleTaskStatus(reader.getName());

        taskStatus.setAutoremove(true);

        taskStatus.setIndeterminate();

        taskStatus.add();

        try {

            List<String> headers;

            taskStatus.message("_preparing");

            readerData.setName(reader.getName());

            boolean ignore_errors = getParameters().getIgnoreErrors();

            headers = getParameters().getFieldNames();

            if ( headers == null ) {

                headers = reader.getFieldNames();

            }

            // Initialize the feature types

            EditableFeatureType edftype = this.getFeatureType(headers, automaticDetectionOfTypes(reader));

            edftype.setLabel(reader.getLabel());

            edftype.setDescription(reader.getDescription());

            Map<String, String> tagsReader = reader.getTags();

            if( tagsReader!=null ) {

                Tags tagsType = edftype.getTags();

                for (Map.Entry<String, String> tag : tagsReader.entrySet()) {

                    tagsType.set(tag.getKey(), tag.getValue());

                }

            }

            FeatureType ftype = edftype.getNotEditableCopy();

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

            ftypes.add(ftype);

            readerData.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 ) {

                readerData.setNeedCalculateEnvelope(true);

            }

            Locale locale = getParameters().getLocale();

            taskStatus.message("_loading");

            long rowCount = reader.getRowCount();

            if( rowCount >0 ) {

                taskStatus.setRangeOfValues(0, rowCount);

            }

            int count = 0;

            int count_errors = 0;

            reader.rewind();

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

            Object rawvalue;

            while ( row != null ) {

                taskStatus.setCurValue(++count);

                FeatureProvider feature = this.createFeatureProvider(ftype);

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

                    try {

                        if( ftype.get(i).isComputed() ) {

                            continue;

                        }

                        rawvalue = row.get(i);

                        if( rawvalue instanceof String && StringUtils.isBlank((String)rawvalue) ) {

                            rawvalue = null;

                        }

                        Object value;

                        if ( locale != null && coercion[i] instanceof CoercionWithLocale ) {

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

                        } else {

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

                        if ( !ignore_errors ) {

                            throw ex;

                        }

                        if ( count_errors++ < 10 ) {

                            LOGGER.warn("Can't load value of attribute " + i+"/"+row.size()+"/"+ftype.size()+ " in row " + count + " in " +readerData.getName()+ ".", ex);

                        }

                        if ( count_errors == 10 ) {

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

                        }

                    }

                }

                readerData.addFeatureProvider(feature);

                row = reader.read();

            }

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

                if ( sizes[i] > 0 ) {

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

                    if( efad.getSize()<sizes[i] ) {

                        efad.setSize(sizes[i]);

                    }

                }

            }

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

            // haber cambiado.

            ftype = edftype.getNotEditableCopy();

            ftypes = new ArrayList<>();

            ftypes.add(ftype);

            readerData.setFeatureTypes(ftypes, ftype);

            taskStatus.terminate();

        } catch (Exception ex) {

            taskStatus.abort();

            LOGGER.warn("Can't load features from '"+getProviderName()+"' file '" + getFullFileName() + "'.", ex);

        }

    }

    private int[] automaticDetectionOfTypes(SimpleSequentialReader reader) throws IOException {

        boolean automatic_types_detection = getParameters().getAutomaticTypesDetection();

        if ( !automatic_types_detection ) {

            return null;

        }

        int[] types = null;

        try {

            reader.rewind();

            List<String> fieldNames = reader.getFieldNames();

            if ( fieldNames == null ) {

                fieldNames = getParameters().getFieldNames();

            }

            AutomaticDetectionOfTypes x = new AutomaticDetectionOfTypes(

                    this.getFullFileName()

            );

            types = x.detect(

                    fieldNames.size(), 

                    reader, 

                    false, 

                    getParameters().getLocale()

            );

        } catch (Exception ex) {

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

        }

        return types;

    }

    @Override

    public boolean hasDynValue(String name) {

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

            return true;

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

            return true;

        }

        return super.hasDynValue(name);

    }

    @Override

    public UnmodifiableBasicMap<String, DataStore> getChildren() {

        return new Children();

    }

}