Application: gvSIG desktop

import java.util.Map;

import javax.json.JsonArray;

import javax.json.JsonObject;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

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

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

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

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.memory.AbstractMemoryStoreProvider;

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

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

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

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

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

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

        }

    }

    @Override

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

        try {

                        features

                                = getStoreServices().getFeatureStore()

                                        .getFeatureSet();

                        FeatureType ftype = getStoreServices().getDefaultFeatureType();

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

                        writer.begin();

    }

    @Override

    public void append(final FeatureProvider featureProvider) {

        //todo

        getResource().execute(new ResourceAction() {

    }

    @Override

    public void beginAppend() throws DataException {

        this.close();

        getResource().execute(new ResourceAction() {

            public Object run() throws Exception {

                writer.initialize(

                        getCSVParameters(),

    }

    @Override

    public void endAppend() {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    writer.end();

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

    }

    @Override

    public Envelope getEnvelope() throws DataException {

        this.open();

        if (this.envelope != null) {

    }

        fType.setHasOID(true);

        FieldTypeParser[] fieldTypes = new FieldTypeParser[headers.length];

        //

        // Calculamos cuales pueden ser los tipos de datos

        //

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

        }

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

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

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

            if (!fieldTypes[i].parse(headers[i])) {

            }

        }

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

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

        if (StringUtils.isNotBlank(param_types_def)) {

            String sep = CSVStoreParameters.getDelimiter(param_types_def);

            if (StringUtils.isNotBlank(sep)) {

                String[] param_types = param_types_def.split(sep);

                for (String param_type : param_types) {

                    parser.clear();

                    parser.parse(param_type);

                    fType.setDefaultGeometryAttributeName(fieldType.name);

                }

            }

            fad.setLocale(locale);

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

                try {

                            break;

                    }

                } catch (Exception ex) {

                }

            }

        }

        if ( pointDimensionNames != null ) {

            PointAttributeEmulator emulator = new PointAttributeEmulator(pointDimensionNames);

            if( StringUtils.isBlank(columnName) ) {

                columnName = "the_geom";

            }

                }

                attr.setGeometryType(gt);

            } catch (Exception e) {

            }

        }        

        if (!StringUtils.isEmpty(geometry_column)) {

            EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) fType.get(geometry_column);

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

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

                    attr.setGeometryType(gt);

                } catch (Exception e) {

                }

                fType.setDefaultGeometryAttributeName(geometry_column);

            }

        }

    }

    static class PointAttributeEmulator implements FeatureAttributeEmulator {

            }

        }

        public void set(EditableFeature feature, Object value) {

            if (value == null) {

                return;

            }

            if (value instanceof MultiPoint) {

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

            } else {

        private String xname = null;

        private String yname = null;

        private String zname = null;

        private int errorcount = 0;

        ToPointEvaluaror(String[] pointDimensionNames) {

        @Override

        public Object evaluate(EvaluatorData data) throws EvaluatorException {

            try {

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

                if (zname != null) {

                    point.setCoordinateAt(2, z);

                }

                return point;

    }

        SimpleReader reader;

        if (FilenameUtils.isExtension(filename, "json")){

//            reader= new JSonReader(in);

        } else {

        }

        return reader;

    }

        char[] header = new char[3];

        String s = String.format("%03d", column);

        return String.valueOf(header);

    }

        String[] headers = new String[count];

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

            headers[i] = getFixedHeader(i);

        return headers;

    }

        Charset charset = Charset.defaultCharset();

        FileInputStream fis = new FileInputStream(f);

        if (!StringUtils.isEmpty(charsetName)) {

                try {

                    charset = Charset.forName(charsetName);

                } catch (Throwable th) {

                }

            } else {

            }

        }

        InputStreamReader isr = new InputStreamReader(fis, charset);

        return isr;

    }

        InputStreamReader in = null;

        SimpleReader reader = null;

        try {

            in = openFile(

            );

            if (headers == null) {

                    headers = reader.getHeader();

                    if (headers == null) {

                            headers = getFixedHeaders(reader.getColumnsCount());

                        } else {

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

                                            .getAbsolutePath()

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

                            LOGGER.warn(msg);

                    headers = getFixedHeaders(reader.getColumnsCount());

                }

            } else {

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

                }

            }

            if (detectedTypes != null && detectedTypes.length > headers.length) {

                // Se han detectado mas columnas que las que hay en la cabezera,

                // a?adimos mas columnas a la cabezera.

                }

            }

            // Initialize the feature types

            FeatureType ftype = edftype.getNotEditableCopy();

            this.setFeatureType(ftype);

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

            CoercionContext coercionContext[] = new CoercionContext[ftype.size()];

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

                } catch (Exception ex) {

                    // Do nothing

                }

            }

            if (in != null) {

                try {

                } catch (Exception ex) {

                    // Do nothing

                }

            }

        }

    }

        if (!automatic_types_detection) {

            return null;

        }

        SimpleReader reader = null;

        try {

            AutomaticDetectionOfTypes x = new AutomaticDetectionOfTypes(

            );

            types = x.detect(

                    headers.length,

                    reader,

            );

        } catch (Exception ex) {

            int lineno = 0;

            if (reader != null) {

                lineno = reader.getLine();

            }

        } finally {

            IOUtils.closeQuietly(reader);

    }

    private void setFeatureType(FeatureType ftype) {

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

        ftypes.add(ftype);

        this.featureType = ftype;

    }

}