Application: gvSIG desktop » gvSIG data providers based on gdal

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 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 2

 * 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.gdal.prov.ogr;

import java.io.File;

import java.util.List;

import java.util.Vector;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gdal.ogr.DataSource;

import org.gdal.ogr.Driver;

import org.gdal.ogr.FieldDefn;

import org.gdal.ogr.GeomFieldDefn;

import org.gdal.ogr.Layer;

import org.gdal.ogr.ogr;

import org.gdal.ogr.ogrConstants;

import org.gdal.osr.SpatialReference;

import org.gvsig.fmap.dal.DALLocator;

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class OGRFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider implements

    FilesystemServerExplorerProvider, ResourceConsumer {

    private static final Logger LOG = LoggerFactory.getLogger(OGRFilesystemServerProvider.class);

    private FilesystemServerExplorerProviderServices serverExplorer;

    @Override

    public String getDataStoreProviderName() {

        return OGRDataStoreProvider.NAME;

    }

    @Override

    public String getDescription() {

        return OGRDataStoreProvider.DESCRIPTION;

    }

    @Override

    public boolean accept(File pathname) {

        if (pathname.isFile() && ogr.Open(pathname.getAbsolutePath(), 1)!=null){

            return true;

        }

        return false;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        // Do nothing

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        // Do nothing

    }

    @Override

    public void initialize(FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public boolean canCreate() {

        throw new UnsupportedOperationException();

    }

    @Override

    public void create(NewDataStoreParameters parameters, boolean overwrite) throws CreateException {

        if (parameters instanceof OGRNewDataStoreParameters) {

            final OGRNewDataStoreParameters newOGRDataStoreParameters =

                (OGRNewDataStoreParameters) parameters;

            final File file = newOGRDataStoreParameters.getFile();

            if (file.isFile() && file.exists()) {

                if (overwrite) {

                    // Deleting existing file

                    try {

                        this.remove(newOGRDataStoreParameters);

                    } catch (RemoveException e) {

                        throw new CreateException("Can not overwrite file", e);

                    }

                } else {

                    throw new CreateException(file.getAbsolutePath(), new IllegalArgumentException(

                        String.format("%1s exists and overwrite option is false",

                            file.getAbsolutePath())));

                }

            }

            try {

                final FileResource resource =

                    (FileResource) serverExplorer.getServerExplorerProviderServices()

                        .createResource(FileResource.NAME, new Object[] { file.getAbsolutePath() });

                resource.addConsumer(this);

                resource.execute(new ResourceAction() {

                    @Override

                    public Object run() throws Exception {

                        String driverName = newOGRDataStoreParameters.getDriverName();

                        Driver driver = ogr.GetDriverByName(driverName);

                        if (driver == null || StringUtils.isBlank(driverName)) {

                            throw new IllegalArgumentException(

                                "Driver name can not be blank and driver must exist.");

                        }

                        List options = newOGRDataStoreParameters.getDatasetCreationOptions();

                        DataSource dataSource = null;

                        if (options == null) {

                            dataSource =

                                driver.CreateDataSource(resource.getFile().getAbsolutePath());

                        } else {

                            dataSource =

                                driver.CreateDataSource(resource.getFile().getAbsolutePath(),

                                    new Vector<String>(options));

                        }

                        if (dataSource == null) {

                            LOG.error("Can not open datasource from {} and {} options", resource

                                .getFile().getAbsoluteFile(), options);

                            throw new ResourceExecuteException(resource, null);

                        }

                        String layerName = newOGRDataStoreParameters.getLayerName();

                        if (StringUtils.isBlank(layerName)) {

                            layerName = file.getName();

                        }

                        // Check if layer already exist at dataSource

                        Layer existingLayer = dataSource.GetLayerByName(layerName);

                        if (existingLayer != null) {

                            for (int i = 0; i < dataSource.GetLayerCount(); i++) {

                                if (dataSource.GetLayerByIndex(i).GetName()

                                    .equals(existingLayer.GetName())) {

                                    dataSource.DeleteLayer(i); // Delete it if

                                                               // exist

                                    break;

                                }

                            }

                        }

                        OGRConverter converter = new OGRConverter();

                        FeatureAttributeDescriptor geometryAttribute =

                            newOGRDataStoreParameters.getDefaultFeatureType()

                                .getDefaultGeometryAttribute();

                        Integer ogrType = null;

                        SpatialReference srs = null;

                        // Determinate if featureType has SRS and geometry type

                        // defined

                        if (geometryAttribute != null) {

                            int type = geometryAttribute.getGeomType().getType();

                            ogrType = converter.convertToOGRGeomType(type);

                            IProjection projection = geometryAttribute.getSRS();

                            if (projection == null && newOGRDataStoreParameters.getCRS() != null) {

                                projection = newOGRDataStoreParameters.getCRS();

                                srs =

                                    new SpatialReference(projection.export(ICRSFactory.FORMAT_WKT));

                            }

                        }

                        Layer layer = null;

                        if (srs == null) {

                            layer = dataSource.CreateLayer(layerName);

                        } else if (ogrType == null) {

                            layer = dataSource.CreateLayer(layerName, srs);

                        } else {

                            layer = dataSource.CreateLayer(layerName, srs, ogrType);

                        }

                        // Creating fields

                        if (layer.TestCapability(ogrConstants.OLCCreateField)) {

                            List<FieldDefn> fields =

                                converter.convertFields(newOGRDataStoreParameters

                                    .getDefaultFeatureType());

                            for (FieldDefn fieldDefn : fields) {

                                layer.CreateField(fieldDefn);

                            }

                        } else {

                            LOG.warn("{} driver does not support creation of fields",

                                driver.getName());

                        }

                        // Creating additional geometry fields, skipping default

                        // geometry column.

                        // When a OGR Layer is created, if feature type has

                        // default geometry column

                        // it will be set when layer is created

                        if (layer.TestCapability(ogrConstants.OLCCreateGeomField)) {

                            List<GeomFieldDefn> geomFields =

                                converter.convertGeometryFields(

                                    newOGRDataStoreParameters.getDefaultFeatureType(), false);

                            for (GeomFieldDefn geomFieldDefn : geomFields) {

                                layer.CreateGeomField(geomFieldDefn);

                            }

                        } else {

                            LOG.warn(

                                "{} driver does not support creation of geometry fields, only default"

                                    + " OGR geometry field has been created", driver.getName());

                        }

                        // Release native resource to close file

                        dataSource.delete();

                        return null;

                    }

                });

            } catch (InitializeException e) {

                throw new CreateException("Can not create file resource to create it", e);

            }

        }

    }

    @Override

    public NewDataStoreParameters getCreateParameters() throws DataException {

        OGRNewDataStoreParameters newParameters = new OGRNewDataStoreParameters();

        EditableFeatureType editableFeatureType = DALLocator.getDataManager().createFeatureType();

        newParameters.setDefaultFeatureType(editableFeatureType);

        return newParameters;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        if (parameters instanceof OGRNewDataStoreParameters) {

            final OGRNewDataStoreParameters newOGRDataStoreParameters =

                (OGRNewDataStoreParameters) parameters;

            File file = newOGRDataStoreParameters.getFile();

            if (!file.exists() && !file.canWrite()) {

                throw new RemoveException(file.getAbsolutePath(), new IllegalArgumentException(

                    String.format("%1s does not exist", file.getAbsolutePath())));

            }

            try {

                final FileResource resource =

                    (FileResource) serverExplorer.getServerExplorerProviderServices()

                        .createResource(FileResource.NAME, new Object[] { file.getAbsolutePath() });

                resource.addConsumer(this);

                resource.execute(new ResourceAction() {

                    @Override

                    public Object run() throws Exception {

                        resource.closeRequest();

                        String driverName = newOGRDataStoreParameters.getDriverName();

                        Driver driver = ogr.GetDriverByName(driverName);

                        if (driver == null || StringUtils.isBlank(driverName)) {

                            LOG.warn("Driver name is blank or driver null, trying to get it opening datasource of resource");

                            DataSource dataSource = ogr.Open(resource.getFile().getAbsolutePath());

                            if (dataSource == null) {

                                LOG.error("Can not determiante driver to remove resource");

                                throw new RemoveException(resource.getName(), null);

                            }

                            driver = dataSource.GetDriver();

                        }

                        if (driver.TestCapability(ogrConstants.ODrCDeleteDataSource)) {

                            driver.DeleteDataSource(resource.getFile().getAbsolutePath());

                        } else {

                            LOG.error("{} driver does not support delete data source",

                                driver.getName());

                            throw new RemoveException(resource.getFile().getAbsolutePath(), null);

                        }

                        return null;

                    }

                });

                resource.addConsumer(this);

            } catch (InitializeException e) {

                throw new RemoveException("Can not create file resource to remove it", e);

            }

        }

    }

    @Override

    public boolean canCreate(NewDataStoreParameters parameters) {

        if (parameters instanceof OGRNewDataStoreParameters) {

            OGRNewDataStoreParameters newOGRDataStoreParameters =

                (OGRNewDataStoreParameters) parameters;

            String driverName = newOGRDataStoreParameters.getDriverName();

            Driver driver = null;

            if (StringUtils.isNotBlank(driverName)) {

                driver = ogr.GetDriverByName(driverName);

            } else {

                return false;

            }

            if (driver.TestCapability(ogrConstants.ODrCCreateDataSource)

                && driver.TestCapability(ogrConstants.OLCCreateField)) {

                File file = newOGRDataStoreParameters.getFile();

                if (file != null && file.canWrite()) {

                    return true;

                }

            }

        }

        return false;

    }

}