Application: gvSIG desktop

import java.io.IOException;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.exception.ResourceExecuteException;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

import org.gvsig.tools.dataTypes.DataTypes;

import org.supercsv.prefs.CsvPreference;

public class CSVFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider

        implements FilesystemServerExplorerProvider, ResourceConsumer {

    protected FilesystemServerExplorerProviderServices serverExplorer;

    public String getDataStoreProviderName() {

        return CSVStoreProvider.NAME;

    }

    public int getMode() {

        return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

    }

    public boolean accept(File pathname) {

        return (pathname.getName().toLowerCase().endsWith(".csv"));

    }

    public String getDescription() {

        return CSVStoreProvider.DESCRIPTION;

    }

    @Override

    public DataStoreParameters getParameters(File file) throws DataException {

        DataManager manager = DALLocator.getDataManager();

        CSVStoreParameters params = (CSVStoreParameters) manager

                .createStoreParameters(this.getDataStoreProviderName());

        params.setFile(file);

        return params;

    }

    @Override

    public boolean canCreate() {

        return true;

    }

    @Override

    public boolean canCreate(NewDataStoreParameters parameters) {

        CSVNewStoreParameters params = (CSVNewStoreParameters) parameters;

        if (params.getFile().getParentFile().canWrite()) {

            return false;

        }

        if (params.getFile().exists()) {

            if (!params.getFile().canWrite()) {

                return false;

            }

        }

        if (params.getDefaultFeatureType() == null) {

            return false;

        }

        return true;

    }

    public void create(NewDataStoreParameters parameters, boolean overwrite)

            throws CreateException {

        final CSVNewStoreParameters params = (CSVNewStoreParameters) parameters;

        final File file = params.getFile();

        if (!file.isAbsolute()) {

            throw new AbsolutePathRequiredException(file.getPath());

        }

        if (file.exists()) {

            if (overwrite) {

//				if (!file.delete()) {

//					throw new CreateException(this.getDataStoreProviderName(),

//							new IOException(

//							"cannot delete file"));

//				}

            } else {

                throw new CreateException(this.getDataStoreProviderName(),

                        new IOException(

                                "file already exist"));

            }

        }

        final FileResource resource;

        try {

            resource = (FileResource) this.serverExplorer

                    .getServerExplorerProviderServices().createResource(

                            FileResource.NAME,

                            new Object[]{file.getAbsolutePath()});

        } catch (InitializeException e1) {

            throw new CreateException(params.getFile().getAbsolutePath(), e1);

        }

        resource.addConsumer(this);

        try {

            resource.execute(new ResourceAction() {

                @Override

                public Object run() throws Exception {

                    CSVFeatureWriter writer = new CSVFeatureWriter();

                    //TODO correct values to the writer from params

                    writer.initialize(params, file.getAbsoluteFile(), params.getDefaultFeatureType(), null);

                    writer.begin();

//                    writer.begin(

//                            params,

//                            fixFeatureType(params.getDefaultFeatureType()),

//                            0

//                    );

                    writer.end();

                    //writer.dispose();

                    resource.notifyChanges();

                    return null;

                }

            });

        } catch (ResourceExecuteException e) {

            throw new CreateException(this.getDataStoreProviderName(), e);

        } finally {

            resource.removeConsumer(this);

        }

    }

    protected NewDataStoreParameters createInstanceNewDataStoreParameters() {

        return new CSVNewStoreParameters();

    }

    @Override

    public NewDataStoreParameters getCreateParameters() {

        NewFeatureStoreParameters params = (NewFeatureStoreParameters) this

                .createInstanceNewDataStoreParameters();

        params.setDefaultFeatureType(this.serverExplorer

                .getServerExplorerProviderServices().createNewFeatureType());

        return params;

    }

    @Override

    public void initialize(FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        CSVStoreParameters params = (CSVStoreParameters) parameters;

        File file = params.getFile();

        if (!file.exists()) {

            throw new RemoveException(this.getDataStoreProviderName(),

                    new FileNotFoundException(params.getFile()));

        }

        if (!file.delete()) {

            throw new RemoveException(this.getDataStoreProviderName(),

                    new IOException()); // FIXME Exception

        }

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        // while it is using a resource anyone can't close it

        return !(this.equals(resource));

    }

    /*

	 * (non-Javadoc)

	 *

	 * @see

	 * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

	 * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    @Override

    public void resourceChanged(ResourceProvider resource) {

        // Do nothing

    }

    protected EditableFeatureType fixFeatureType(FeatureType featureType) {

        EditableFeatureType newFeatureType;

        if (featureType instanceof EditableFeatureType) {

            newFeatureType = (EditableFeatureType) featureType.getCopy();

        } else {

            newFeatureType = featureType.getEditable();

        }

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

            EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) newFeatureType.getAttributeDescriptor(i);

            String s;

            switch (attr.getType()) {

                case DataTypes.INT:

                    s = String.valueOf(Integer.MAX_VALUE);

                    attr.setSize(18);

                    attr.setPrecision(0);

                    break;

                case DataTypes.LONG:

                    s = String.valueOf(Long.MAX_VALUE);

                    attr.setSize(18);

                    attr.setPrecision(0);

                    break;

                case DataTypes.FLOAT:

                    attr.setSize(18);

                    attr.setPrecision(6);

                    break;

                case DataTypes.DOUBLE:

                    attr.setSize(18);

                    attr.setPrecision(6);

                    break;

            }

        }

        return newFeatureType;

    }